Tidy fpdfsdk/fpdf_flatten.cpp

fpdfsdk/fpdf_flatten.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 "public/fpdf_flatten.h"
 
 #include <algorithm>
 
 #include "core/fpdfapi/page/cpdf_page.h"
 #include "core/fpdfapi/page/cpdf_pageobject.h"
 #include "core/fpdfapi/parser/cpdf_array.h"
 #include "core/fpdfapi/parser/cpdf_document.h"
 #include "core/fpdfapi/parser/cpdf_number.h"
 #include "core/fpdfapi/parser/cpdf_stream.h"
 #include "core/fpdfapi/parser/cpdf_stream_acc.h"
 #include "core/fpdfdoc/cpdf_annot.h"
 #include "fpdfsdk/fsdk_define.h"
 #include "third_party/base/stl_util.h"
 
-typedef CFX_ArrayTemplate<CFX_FloatRect> CPDF_RectArray;
-
 enum FPDF_TYPE { MAX, MIN };
 enum FPDF_VALUE { TOP, LEFT, RIGHT, BOTTOM };
 
 namespace {
 
 bool IsValiableRect(CFX_FloatRect rect, CFX_FloatRect rcPage) {
   if (rect.left - rect.right > 0.000001f || rect.bottom - rect.top > 0.000001f)
     return false;
 
   if (rect.left == 0.0f && rect.top == 0.0f && rect.right == 0.0f &&
       rect.bottom == 0.0f)
     return false;
 
   if (!rcPage.IsEmpty()) {
     if (rect.left - rcPage.left < -10.000001f ||
         rect.right - rcPage.right > 10.000001f ||
         rect.top - rcPage.top > 10.000001f ||
         rect.bottom - rcPage.bottom < -10.000001f)
       return false;
   }
 
   return true;
 }
 
 void GetContentsRect(CPDF_Document* pDoc,
                      CPDF_Dictionary* pDict,
-                     CPDF_RectArray* pRectArray) {
+                     std::vector<CFX_FloatRect>* pRectArray) {
   std::unique_ptr<CPDF_Page> pPDFPage(new CPDF_Page(pDoc, pDict, false));
   pPDFPage->ParseContent();
 
   for (const auto& pPageObject : *pPDFPage->GetPageObjectList()) {
     CFX_FloatRect rc;
     rc.left = pPageObject->m_Left;
     rc.right = pPageObject->m_Right;
     rc.bottom = pPageObject->m_Bottom;
     rc.top = pPageObject->m_Top;
     if (IsValiableRect(rc, pDict->GetRectFor("MediaBox")))
-      pRectArray->Add(rc);
+      pRectArray->push_back(rc);
   }
 }
 
 void ParserStream(CPDF_Dictionary* pPageDic,
                   CPDF_Dictionary* pStream,
-                  CPDF_RectArray* pRectArray,
+                  std::vector<CFX_FloatRect>* pRectArray,
                   std::vector<CPDF_Dictionary*>* pObjectArray) {
   if (!pStream)
     return;
   CFX_FloatRect rect;
   if (pStream->KeyExist("Rect"))
     rect = pStream->GetRectFor("Rect");
   else if (pStream->KeyExist("BBox"))
     rect = pStream->GetRectFor("BBox");
 
   if (IsValiableRect(rect, pPageDic->GetRectFor("MediaBox")))
-    pRectArray->Add(rect);
+    pRectArray->push_back(rect);
 
   pObjectArray->push_back(pStream);
 }
 
 int ParserAnnots(CPDF_Document* pSourceDoc,
                  CPDF_Dictionary* pPageDic,
-                 CPDF_RectArray* pRectArray,
+                 std::vector<CFX_FloatRect>* pRectArray,
                  std::vector<CPDF_Dictionary*>* pObjectArray,
                  int nUsage) {
   if (!pSourceDoc || !pPageDic)
     return FLATTEN_FAIL;
 
   GetContentsRect(pSourceDoc, pPageDic, pRectArray);
   CPDF_Array* pAnnots = pPageDic->GetArrayFor("Annots");
   if (!pAnnots)
     return FLATTEN_NOTHINGTODO;
 
@@ skipping 17 matching lines @@
 
       ParserStream(pPageDic, pAnnotDic, pRectArray, pObjectArray);
     } else {
       if (nAnnotFlag & ANNOTFLAG_PRINT)
         ParserStream(pPageDic, pAnnotDic, pRectArray, pObjectArray);
     }
   }
   return FLATTEN_SUCCESS;
 }
 
-FX_FLOAT GetMinMaxValue(CPDF_RectArray& array,
+FX_FLOAT GetMinMaxValue(const std::vector<CFX_FloatRect>& array,
                         FPDF_TYPE type,
                         FPDF_VALUE value) {
-  int nRects = array.GetSize();
-  FX_FLOAT fRet = 0.0f;
-
+  size_t nRects = array.size();
   if (nRects <= 0)
     return 0.0f;
 
-  FX_FLOAT* pArray = new FX_FLOAT[nRects];
+  std::vector<FX_FLOAT> pArray(nRects);
   switch (value) {
-    case LEFT: {
-      for (int i = 0; i < nRects; i++)
-        pArray[i] = CFX_FloatRect(array.GetAt(i)).left;
-
+    case LEFT:
+      for (size_t i = 0; i < nRects; i++)
+        pArray[i] = array[i].left;
       break;
-    }
-    case TOP: {
-      for (int i = 0; i < nRects; i++)
-        pArray[i] = CFX_FloatRect(array.GetAt(i)).top;
-
+    case TOP:
+      for (size_t i = 0; i < nRects; i++)
+        pArray[i] = array[i].top;
       break;
-    }
-    case RIGHT: {
-      for (int i = 0; i < nRects; i++)
-        pArray[i] = CFX_FloatRect(array.GetAt(i)).right;
-
+    case RIGHT:
+      for (size_t i = 0; i < nRects; i++)
+        pArray[i] = array[i].right;
       break;
-    }
-    case BOTTOM: {
-      for (int i = 0; i < nRects; i++)
-        pArray[i] = CFX_FloatRect(array.GetAt(i)).bottom;
-
+    case BOTTOM:
+      for (size_t i = 0; i < nRects; i++)
+        pArray[i] = array[i].bottom;
       break;
-    }
     default:
       // Not reachable.
       return 0.0f;
   }
-  fRet = pArray[0];
+
+  FX_FLOAT fRet = pArray[0];
   if (type == MAX) {
-    for (int i = 1; i < nRects; i++)
-      if (fRet <= pArray[i])
-        fRet = pArray[i];
+    for (size_t i = 1; i < nRects; i++)
+      fRet = std::max(fRet, pArray[i]);
   } else {
-    for (int i = 1; i < nRects; i++)
-      if (fRet >= pArray[i])
-        fRet = pArray[i];
+    for (size_t i = 1; i < nRects; i++)
+      fRet = std::min(fRet, pArray[i]);
   }
-  delete[] pArray;
   return fRet;
 }
 
-CFX_FloatRect CalculateRect(CPDF_RectArray* pRectArray) {
+CFX_FloatRect CalculateRect(std::vector<CFX_FloatRect>* pRectArray) {
   CFX_FloatRect rcRet;
 
   rcRet.left = GetMinMaxValue(*pRectArray, MIN, LEFT);
   rcRet.top = GetMinMaxValue(*pRectArray, MAX, TOP);
   rcRet.right = GetMinMaxValue(*pRectArray, MAX, RIGHT);
   rcRet.bottom = GetMinMaxValue(*pRectArray, MIN, BOTTOM);
 
   return rcRet;
 }
 
@@ skipping 56 matching lines @@
 
   FX_FLOAT e = rcAnnot.left - rcStream.left * a;
   FX_FLOAT f = rcAnnot.bottom - rcStream.bottom * d;
   return CFX_Matrix(a, 0, 0, d, e, f);
 }
 
 }  // namespace
 
 DLLEXPORT int STDCALL FPDFPage_Flatten(FPDF_PAGE page, int nFlag) {
   CPDF_Page* pPage = CPDFPageFromFPDFPage(page);
-  if (!page) {
+  if (!page)
     return FLATTEN_FAIL;
-  }
 
   CPDF_Document* pDocument = pPage->m_pDocument;
   CPDF_Dictionary* pPageDict = pPage->m_pFormDict;
-
-  if (!pDocument || !pPageDict) {
+  if (!pDocument || !pPageDict)
     return FLATTEN_FAIL;
-  }
 
   std::vector<CPDF_Dictionary*> ObjectArray;
-  CPDF_RectArray RectArray;
-
-  int iRet = FLATTEN_FAIL;
-  iRet = ParserAnnots(pDocument, pPageDict, &RectArray, &ObjectArray, nFlag);
+  std::vector<CFX_FloatRect> RectArray;
+  int iRet =
+      ParserAnnots(pDocument, pPageDict, &RectArray, &ObjectArray, nFlag);
   if (iRet == FLATTEN_NOTHINGTODO || iRet == FLATTEN_FAIL)
     return iRet;
 
   CFX_FloatRect rcOriginalCB;
   CFX_FloatRect rcMerger = CalculateRect(&RectArray);
   CFX_FloatRect rcOriginalMB = pPageDict->GetRectFor("MediaBox");
-
   if (pPageDict->KeyExist("CropBox"))
     rcOriginalMB = pPageDict->GetRectFor("CropBox");
 
-  if (rcOriginalMB.IsEmpty()) {
+  if (rcOriginalMB.IsEmpty())
     rcOriginalMB = CFX_FloatRect(0.0f, 0.0f, 612.0f, 792.0f);
-  }
 
-  rcMerger.left =
-      rcMerger.left < rcOriginalMB.left ? rcOriginalMB.left : rcMerger.left;
-  rcMerger.right =
-      rcMerger.right > rcOriginalMB.right ? rcOriginalMB.right : rcMerger.right;
-  rcMerger.top =
-      rcMerger.top > rcOriginalMB.top ? rcOriginalMB.top : rcMerger.top;
-  rcMerger.bottom = rcMerger.bottom < rcOriginalMB.bottom ? rcOriginalMB.bottom
-                                                          : rcMerger.bottom;
-
+  rcMerger.left = std::max(rcMerger.left, rcOriginalMB.left);
+  rcMerger.right = std::min(rcMerger.right, rcOriginalMB.right);
+  rcMerger.bottom = std::max(rcMerger.bottom, rcOriginalMB.bottom);
+  rcMerger.top = std::min(rcMerger.top, rcOriginalMB.top);
   if (pPageDict->KeyExist("ArtBox"))
     rcOriginalCB = pPageDict->GetRectFor("ArtBox");
   else
     rcOriginalCB = rcOriginalMB;
 
   if (!rcOriginalMB.IsEmpty()) {
     CPDF_Array* pMediaBox = new CPDF_Array();
     pMediaBox->Add(new CPDF_Number(rcOriginalMB.left));
     pMediaBox->Add(new CPDF_Number(rcOriginalMB.bottom));
     pMediaBox->Add(new CPDF_Number(rcOriginalMB.right));
@@ skipping 21 matching lines @@
 
   uint32_t dwObjNum = pDocument->AddIndirectObject(pNewXObject);
   CPDF_Dictionary* pPageXObject = pRes->GetDictFor("XObject");
   if (!pPageXObject) {
     pPageXObject = new CPDF_Dictionary(pDocument->GetByteStringPool());
     pRes->SetFor("XObject", pPageXObject);
   }
 
   CFX_ByteString key = "";
   int nStreams = pdfium::CollectionSize<int>(ObjectArray);
-
   if (nStreams > 0) {
     for (int iKey = 0; /*iKey < 100*/; iKey++) {
       char sExtend[5] = {};
       FXSYS_itoa(iKey, sExtend, 10);
       key = CFX_ByteString("FFT") + CFX_ByteString(sExtend);
       if (!pPageXObject->KeyExist(key))
         break;
     }
   }
 
   SetPageContents(key, pPageDict, pDocument);
 
   CPDF_Dictionary* pNewXORes = nullptr;
-
   if (!key.IsEmpty()) {
     pPageXObject->SetReferenceFor(key, pDocument, dwObjNum);
     CPDF_Dictionary* pNewOXbjectDic = pNewXObject->GetDict();
     pNewXORes = new CPDF_Dictionary(pDocument->GetByteStringPool());
     pNewOXbjectDic->SetFor("Resources", pNewXORes);
     pNewOXbjectDic->SetNameFor("Type", "XObject");
     pNewOXbjectDic->SetNameFor("Subtype", "Form");
     pNewOXbjectDic->SetIntegerFor("FormType", 1);
     pNewOXbjectDic->SetNameFor("Name", "FRM");
     CFX_FloatRect rcBBox = pPageDict->GetRectFor("ArtBox");
@@ skipping 87 matching lines @@
     }
 
     CFX_ByteString sTemp;
     CFX_Matrix m = GetMatrix(rcAnnot, rcStream, matrix);
     sTemp.Format("q %f 0 0 %f %f %f cm /%s Do Q\n", m.a, m.d, m.e, m.f,
                  sFormName.c_str());
     sStream += sTemp;
     pNewXObject->SetData(sStream.raw_str(), sStream.GetLength());
   }
   pPageDict->RemoveFor("Annots");
-
-  RectArray.RemoveAll();
   return FLATTEN_SUCCESS;
 }