Replace CFX_WideStringCArray with std::vector.

xfa/fxfa/fm2js/xfa_fmparse.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/fm2js/xfa_fmparse.h"
 
 #include <memory>
 #include <utility>
@@ skipping 60 matching lines @@
         expressions.push_back(std::move(expr));
       } else {
         break;
       }
     }
   }
   return expressions;
 }
 
 std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseFunction() {
-  std::unique_ptr<CXFA_FMExpression> expr;
   CFX_WideStringC ident;
-  std::unique_ptr<CFX_WideStringCArray> pArguments;
+  std::vector<CFX_WideStringC> arguments;
   std::vector<std::unique_ptr<CXFA_FMExpression>> expressions;
   uint32_t line = m_pToken->m_uLinenum;
   NextToken();
   if (m_pToken->m_type != TOKidentifier) {
     CFX_WideString ws_TempString(m_pToken->m_wstring);
     Error(m_pToken->m_uLinenum, kFMErrExpectedIdentifier,
           ws_TempString.c_str());
   } else {
     ident = m_pToken->m_wstring;
     NextToken();
   }
   Check(TOKlparen);
   if (m_pToken->m_type == TOKrparen) {
     NextToken();
   } else {
-    pArguments = pdfium::MakeUnique<CFX_WideStringCArray>();
-    CFX_WideStringC p;
     while (1) {
       if (m_pToken->m_type == TOKidentifier) {
-        p = m_pToken->m_wstring;
-        pArguments->Add(p);
+        arguments.push_back(m_pToken->m_wstring);
         NextToken();
         if (m_pToken->m_type == TOKcomma) {
           NextToken();
           continue;
         } else if (m_pToken->m_type == TOKrparen) {
           NextToken();
           break;
         } else {
           Check(TOKrparen);
           break;
         }
       } else {
         CFX_WideString ws_TempString(m_pToken->m_wstring);
         Error(m_pToken->m_uLinenum, kFMErrExpectedIdentifier,
               ws_TempString.c_str());
         NextToken();
         break;
       }
     }
   }
   Check(TOKdo);
   if (m_pToken->m_type == TOKendfunc) {
     NextToken();
   } else {
     expressions = ParseTopExpression();
     Check(TOKendfunc);
   }
-  if (m_pErrorInfo->message.IsEmpty()) {
-    expr = pdfium::MakeUnique<CXFA_FMFunctionDefinition>(
-        line, false, ident, std::move(pArguments), std::move(expressions));
-  } else if (pArguments) {
-    pArguments->RemoveAll();
-  }
-  return expr;
+  if (!m_pErrorInfo->message.IsEmpty())
+    return nullptr;
+
+  return pdfium::MakeUnique<CXFA_FMFunctionDefinition>(
+      line, false, ident, std::move(arguments), std::move(expressions));
 }
 
 std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseExpression() {
   std::unique_ptr<CXFA_FMExpression> expr;
   uint32_t line = m_pToken->m_uLinenum;
   switch (m_pToken->m_type) {
     case TOKvar:
       expr = ParseVarExpression();
       break;
     case TOKnull:
@@ skipping 870 matching lines @@
 std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseDoExpression() {
   uint32_t line = m_pToken->m_uLinenum;
   NextToken();
   std::unique_ptr<CXFA_FMExpression> expr = ParseBlockExpression();
   Check(TOKend);
   if (!m_pErrorInfo->message.IsEmpty())
     return nullptr;
 
   return pdfium::MakeUnique<CXFA_FMDoExpression>(line, std::move(expr));
 }