Replace CXFA_StrokeArray and CXFA_WidgetArray with std::vector

xfa/fxfa/app/xfa_ffwidget.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 "xfa/fxfa/xfa_ffwidget.h"
 
 #include <algorithm>
 #include <memory>
@@ skipping 1199 matching lines @@
   if (!bStart && !bEnd) {
     fillPath.AddEllipse(rtDraw);
     return;
   }
   startAngle = -startAngle * FX_PI / 180.0f;
   sweepAngle = -sweepAngle * FX_PI / 180.0f;
   fillPath.AddArc(rtDraw.left, rtDraw.top, rtDraw.width, rtDraw.height,
                   startAngle, sweepAngle);
 }
 static void XFA_BOX_GetPath(CXFA_Box box,
-                            const CXFA_StrokeArray& strokes,
+                            const std::vector<CXFA_Stroke>& strokes,
                             CFX_RectF rtWidget,
                             CFX_Path& path,
                             int32_t nIndex,
                             bool bStart,
                             bool bCorner) {
   ASSERT(nIndex >= 0 && nIndex < 8);
   int32_t n = (nIndex & 1) ? nIndex - 1 : nIndex;
   CXFA_Corner corner1(strokes[n].GetNode());
   CXFA_Corner corner2(strokes[(n + 2) % 8].GetNode());
   FX_FLOAT fRadius1 = bCorner ? corner1.GetRadius() : 0.0f;
@@ skipping 147 matching lines @@
       cp.x = cp1.x + fRadius1 * vx, cp.y = cp1.y + fRadius1 * vy;
     } else {
       cp = cp1;
     }
     path.LineTo(cp.x, cp.y);
     path.LineTo(cp1.x + fRadius1 * sx + offsetX,
                 cp1.y + fRadius1 * sy + offsetY);
   }
 }
 static void XFA_BOX_GetFillPath(CXFA_Box box,
-                                const CXFA_StrokeArray& strokes,
+                                const std::vector<CXFA_Stroke>& strokes,
                                 CFX_RectF rtWidget,
                                 CFX_Path& fillPath,
                                 uint16_t dwFlags) {
   if (box.IsArc() || (dwFlags & XFA_DRAWBOX_ForceRound) != 0) {
     CXFA_Edge edge = box.GetEdge(0);
     FX_FLOAT fThickness = edge.GetThickness();
     if (fThickness < 0) {
       fThickness = 0;
     }
     FX_FLOAT fHalf = fThickness / 2;
@@ skipping 225 matching lines @@
       break;
     default:
       break;
   }
   CFX_Shading shading(ptStart, ptEnd, false, false, crStart, crEnd);
   CFX_Color cr(&shading);
   pGS->SetFillColor(&cr);
   pGS->FillPath(&fillPath, FXFILL_WINDING, pMatrix);
 }
 static void XFA_BOX_Fill(CXFA_Box box,
-                         const CXFA_StrokeArray& strokes,
+                         const std::vector<CXFA_Stroke>& strokes,
                          CFX_Graphics* pGS,
                          const CFX_RectF& rtWidget,
                          CFX_Matrix* pMatrix,
                          uint32_t dwFlags) {
   CXFA_Fill fill = box.GetFill();
   if (!fill || fill.GetPresence() != XFA_ATTRIBUTEENUM_Visible) {
     return;
   }
   pGS->SaveGraphState();
   CFX_Path fillPath;
@@ skipping 218 matching lines @@
                                            CFX_RectF rt,
                                            FX_FLOAT fThickness,
                                            CFX_Matrix* pMatrix) {
   FX_FLOAT fHalfWidth = fThickness / 2.0f;
   XFA_Draw3DRect(pGS, rt, fThickness, pMatrix, 0xFF808080, 0xFF000000);
   CFX_RectF rtInner(rt);
   rtInner.Deflate(fHalfWidth, fHalfWidth);
   XFA_Draw3DRect(pGS, rtInner, fHalfWidth, pMatrix, 0xFF000000, 0xFF808080);
 }
 static void XFA_BOX_Stroke_Rect(CXFA_Box box,
-                                const CXFA_StrokeArray& strokes,
+                                const std::vector<CXFA_Stroke>& strokes,
                                 CFX_Graphics* pGS,
                                 CFX_RectF rtWidget,
                                 CFX_Matrix* pMatrix) {
   bool bVisible = false;
   FX_FLOAT fThickness = 0;
   int32_t i3DType = box.Get3DStyle(bVisible, fThickness);
   if (i3DType) {
     if (!bVisible || fThickness < 0.001f) {
       return;
     }
@@ skipping 70 matching lines @@
   }
   bool bEmpty = path.IsEmpty();
   if (!bEmpty) {
     if (bClose) {
       path.Close();
     }
     XFA_BOX_StrokePath(strokes[7], &path, pGS, pMatrix);
   }
 }
 static void XFA_BOX_Stroke(CXFA_Box box,
-                           const CXFA_StrokeArray& strokes,
+                           const std::vector<CXFA_Stroke>& strokes,
                            CFX_Graphics* pGS,
                            CFX_RectF rtWidget,
                            CFX_Matrix* pMatrix,
                            uint32_t dwFlags) {
   if (box.IsArc() || (dwFlags & XFA_DRAWBOX_ForceRound) != 0) {
     XFA_BOX_StrokeArc(box, pGS, rtWidget, pMatrix, dwFlags);
     return;
   }
   bool bVisible = false;
   for (int32_t j = 0; j < 4; j++) {
@@ skipping 56 matching lines @@
                  CFX_Matrix* pMatrix,
                  uint32_t dwFlags) {
   if (!box || box.GetPresence() != XFA_ATTRIBUTEENUM_Visible)
     return;
 
   XFA_Element eType = box.GetElementType();
   if (eType != XFA_Element::Arc && eType != XFA_Element::Border &&
       eType != XFA_Element::Rectangle) {
     return;
   }
-  CXFA_StrokeArray strokes;
-  if (!(dwFlags & XFA_DRAWBOX_ForceRound) && eType != XFA_Element::Arc) {
-    box.GetStrokes(strokes);
-  }
+  std::vector<CXFA_Stroke> strokes;
+  if (!(dwFlags & XFA_DRAWBOX_ForceRound) && eType != XFA_Element::Arc)
+    box.GetStrokes(&strokes);
+
   XFA_BOX_Fill(box, strokes, pGS, rtWidget, pMatrix, dwFlags);
   XFA_BOX_Stroke(box, strokes, pGS, rtWidget, pMatrix, dwFlags);
 }
 
 CXFA_CalcData::CXFA_CalcData() : m_iRefCount(0) {}
 
 CXFA_CalcData::~CXFA_CalcData() {
   m_Globals.RemoveAll();
 }