More unique_ptrs in CXFA_FMParse::ParseForeachExpression and avoid leaks

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>
+#include <vector>
+
+#include "third_party/base/ptr_util.h"
 
 CXFA_FMParse::CXFA_FMParse() : m_pToken(nullptr), m_pErrorInfo(0) {}
 
 CXFA_FMParse::~CXFA_FMParse() {}
 
 int32_t CXFA_FMParse::Init(const CFX_WideStringC& wsFormcalc,
                            CXFA_FMErrorInfo* pErrorInfo) {
   m_pErrorInfo = pErrorInfo;
   m_lexer.reset(new CXFA_FMLexer(wsFormcalc, m_pErrorInfo));
   return 0;
@@ skipping 961 matching lines @@
     e.reset(new CXFA_FMForExpression(line, wsVariant, pAssignment.release(),
                                      pAccessor.release(), iDirection,
                                      pStep.release(), pList.release()));
   }
   return e.release();
 }
 
 CXFA_FMExpression* CXFA_FMParse::ParseForeachExpression() {
   std::unique_ptr<CXFA_FMExpression> e;
   CFX_WideStringC wsIdentifier;
-  std::unique_ptr<CFX_ArrayTemplate<CXFA_FMSimpleExpression*>> pAccessors;
+  std::vector<std::unique_ptr<CXFA_FMSimpleExpression>> pAccessors;
   std::unique_ptr<CXFA_FMExpression> pList;
   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, kFMErrExpectedToken,
           XFA_FM_KeywordToString(m_pToken->m_type), ws_TempString.c_str());
   }
   wsIdentifier = m_pToken->m_wstring;
   NextToken();
   Check(TOKin);
   Check(TOKlparen);
   if (m_pToken->m_type == TOKrparen) {
     CFX_WideString ws_TempString(m_pToken->m_wstring);
     Error(m_pToken->m_uLinenum, kFMErrUnexpectedExpression,
           ws_TempString.c_str());
     NextToken();
   } else {
-    pAccessors.reset(new CFX_ArrayTemplate<CXFA_FMSimpleExpression*>());
     while (m_pToken->m_type != TOKrparen) {
       CXFA_FMSimpleExpression* s = ParseSimpleExpression();

[Tom Sepez, 2016/11/23 20:21:55]

Things get cleaner if ParseSimpleExpression returned unique_ptrs.

[npm, 2016/11/23 20:40:27]

There is a long chain down. Is it ok if I do it in a followup?

       if (s) {
-        pAccessors->Add(s);
+        pAccessors.push_back(std::unique_ptr<CXFA_FMSimpleExpression>(s));

[dsinclair, 2016/11/23 19:38:46]

pAccessors.push_back(pdfium::WrapUnique<CXFA_FMSimpleExpression>(s));

Don't need {}'s

[npm, 2016/11/23 20:40:27]

Done.

       }
       if (m_pToken->m_type == TOKcomma) {
         NextToken();
       } else {

[dsinclair, 2016/11/23 19:38:46]

If you flip the condtions this can become:

if (m_pToken->m_type != TOKcomma)
  break;
NextToken();

[npm, 2016/11/23 20:40:27]

Done.

         break;
       }
     }
     Check(TOKrparen);
   }
   Check(TOKdo);
   pList.reset(ParseBlockExpression());
   Check(TOKendfor);
   if (m_pErrorInfo->message.IsEmpty()) {
-    e.reset(new CXFA_FMForeachExpression(
-        line, wsIdentifier, pAccessors.release(), pList.release()));
-  } else {
-    if (pAccessors) {
-      for (int i = 0; i < pAccessors->GetSize(); ++i)
-        delete static_cast<CXFA_FMSimpleExpression*>(pAccessors->GetAt(i));
-    }
+    e = pdfium::MakeUnique<CXFA_FMForeachExpression>(
+        line, wsIdentifier, std::move(pAccessors), pList.release());
   }
   return e.release();
 }
 
 CXFA_FMExpression* CXFA_FMParse::ParseDoExpression() {
   std::unique_ptr<CXFA_FMExpression> e;
   uint32_t line = m_pToken->m_uLinenum;
   NextToken();
   e.reset(ParseBlockExpression());
   Check(TOKend);
   if (m_pErrorInfo->message.IsEmpty()) {
     e.reset(new CXFA_FMDoExpression(line, e.release()));
   } else {
     e.reset();
   }
   return e.release();
 }