Cleanup ownership in CXFA_ScriptContext.

xfa/fxfa/parser/xfa_script_imp.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/parser/xfa_script_imp.h"
 
 #include "core/fxcrt/include/fx_ext.h"
 #include "fxjse/include/cfxjse_arguments.h"
@@ skipping 63 matching lines @@
 }  // namespace
 
 // static.
 CXFA_Object* CXFA_ScriptContext::ToObject(CFXJSE_Value* pValue,
                                           CFXJSE_Class* pClass) {
   return static_cast<CXFA_Object*>(pValue->ToHostObject(pClass));
 }
 
 CXFA_ScriptContext::CXFA_ScriptContext(CXFA_Document* pDocument)
     : m_pDocument(pDocument),
-      m_pJsContext(nullptr),
+      m_JsContext(nullptr),

[Lei Zhang, 2016/06/14 19:29:12]

No need to initialize an unique_ptr. Ditto below.

[dsinclair, 2016/06/14 20:19:43]

Done.

       m_pIsolate(nullptr),
       m_pJsClass(nullptr),
       m_eScriptType(XFA_SCRIPTLANGTYPE_Unkown),
       m_pScriptNodeArray(nullptr),
-      m_pResolveProcessor(nullptr),
-      m_hFM2JSContext(nullptr),
+      m_ResolveProcessor(nullptr),
+      m_FM2JSContext(nullptr),
       m_pThisObject(nullptr),
       m_dwBuiltInInFlags(0),
-      m_eRunAtType(XFA_ATTRIBUTEENUM_Client) {
-}
+      m_eRunAtType(XFA_ATTRIBUTEENUM_Client) {}
 
 CXFA_ScriptContext::~CXFA_ScriptContext() {
-  FX_POSITION ps = m_mapXFAToValue.GetStartPosition();
+  FX_POSITION ps = m_mapVariableToContext.GetStartPosition();
   while (ps) {
-    CXFA_Object* pXFAObj;
-    CFXJSE_Value* pValue;
-    m_mapXFAToValue.GetNextAssoc(ps, pXFAObj, pValue);
-    delete pValue;
+    CXFA_Object* pScriptNode;
+    CFXJSE_Context* pVariableContext = nullptr;
+    m_mapVariableToContext.GetNextAssoc(ps, pScriptNode, pVariableContext);
+
+    delete ToThisProxy(pVariableContext->GetGlobalObject().get(), nullptr);

[dsinclair, 2016/06/14 19:01:35]

Don't think we can easily convert this to std::map because the delete deletes an
object that we get from the context, not the context itself.

[Lei Zhang, 2016/06/14 19:29:12]

Are you referring to |m_mapVariableToContext|? Did you mean it's hard to convert
to a std::map that holds unique_ptrs?

[dsinclair, 2016/06/14 20:19:43]

Sorry, yea, converting m_mapVariableToContext to a std::map that holds
std::unique_ptrs is difficult is what I'm trying to say.

+    delete pVariableContext;
   }
-  m_mapXFAToValue.RemoveAll();
-  ReleaseVariablesMap();
+  m_mapVariableToContext.RemoveAll();
 
-  delete m_hFM2JSContext;
-  delete m_pJsContext;
-
-  delete m_pResolveProcessor;
   m_upObjectArray.RemoveAll();
-  for (int32_t i = 0; i < m_CacheListArray.GetSize(); i++)
-    delete m_CacheListArray[i];
 }
 void CXFA_ScriptContext::Initialize(v8::Isolate* pIsolate) {
   m_pIsolate = pIsolate;
   DefineJsContext();
   DefineJsClass();
-  m_pResolveProcessor = new CXFA_ResolveProcessor;
+  m_ResolveProcessor.reset(new CXFA_ResolveProcessor);
 }
 FX_BOOL CXFA_ScriptContext::RunScript(XFA_SCRIPTLANGTYPE eScriptType,
                                       const CFX_WideStringC& wsScript,
                                       CFXJSE_Value* hRetValue,
                                       CXFA_Object* pThisObject) {
   CFX_ByteString btScript;
   XFA_SCRIPTLANGTYPE eSaveType = m_eScriptType;
   m_eScriptType = eScriptType;
   if (eScriptType == XFA_SCRIPTLANGTYPE_Formcalc) {
-    if (!m_hFM2JSContext) {
-      m_hFM2JSContext =
-          new CXFA_FM2JSContext(m_pIsolate, m_pJsContext, m_pDocument);
+    if (!m_FM2JSContext) {
+      m_FM2JSContext.reset(
+          new CXFA_FM2JSContext(m_pIsolate, m_JsContext.get(), m_pDocument));
     }
     CFX_WideTextBuf wsJavaScript;
     CFX_WideString wsErrorInfo;
     int32_t iFlags =
         CXFA_FM2JSContext::Translate(wsScript, wsJavaScript, wsErrorInfo);
     if (iFlags) {
       hRetValue->SetUndefined();
       return FALSE;
     }
     btScript =
         FX_UTF8Encode(wsJavaScript.GetBuffer(), wsJavaScript.GetLength());
   } else {
     btScript = FX_UTF8Encode(wsScript.c_str(), wsScript.GetLength());
   }
   CXFA_Object* pOriginalObject = m_pThisObject;
   m_pThisObject = pThisObject;
-  CFXJSE_Value* pValue = pThisObject ? GetJSValueFromMap(pThisObject) : NULL;
+  CFXJSE_Value* pValue = pThisObject ? GetJSValueFromMap(pThisObject) : nullptr;
   FX_BOOL bRet =
-      m_pJsContext->ExecuteScript(btScript.c_str(), hRetValue, pValue);
+      m_JsContext->ExecuteScript(btScript.c_str(), hRetValue, pValue);
   m_pThisObject = pOriginalObject;
   m_eScriptType = eSaveType;
   return bRet;
 }
 void CXFA_ScriptContext::GlobalPropertySetter(CFXJSE_Value* pObject,
                                               const CFX_ByteStringC& szPropName,
                                               CFXJSE_Value* pValue) {
   CXFA_Object* lpOrginalNode = ToObject(pObject, nullptr);
   CXFA_Document* pDoc = lpOrginalNode->GetDocument();
   CXFA_ScriptContext* lpScriptContext = pDoc->GetScriptContext();
@@ skipping 49 matching lines @@
 void CXFA_ScriptContext::GlobalPropertyGetter(CFXJSE_Value* pObject,
                                               const CFX_ByteStringC& szPropName,
                                               CFXJSE_Value* pValue) {
   CXFA_Object* pOriginalObject = ToObject(pObject, nullptr);
   CXFA_Document* pDoc = pOriginalObject->GetDocument();
   CXFA_ScriptContext* lpScriptContext = pDoc->GetScriptContext();
   CXFA_Object* lpCurNode = lpScriptContext->GetVariablesThis(pOriginalObject);
   CFX_WideString wsPropName = CFX_WideString::FromUTF8(szPropName);
   if (lpScriptContext->GetType() == XFA_SCRIPTLANGTYPE_Formcalc) {
     if (szPropName == kFormCalcRuntime) {
-      lpScriptContext->m_hFM2JSContext->GlobalPropertyGetter(pValue);
+      lpScriptContext->m_FM2JSContext->GlobalPropertyGetter(pValue);
       return;
     }
     XFA_HashCode uHashCode = static_cast<XFA_HashCode>(
         FX_HashCode_GetW(wsPropName.AsStringC(), false));
     if (uHashCode != XFA_HASHCODE_Layout) {
       CXFA_Object* pObj =
           lpScriptContext->GetDocument()->GetXFAObject(uHashCode);
       if (pObj) {
         pValue->Assign(lpScriptContext->GetJSValueFromMap(pObj));
         return;
@@ skipping 89 matching lines @@
       pObject->GetClassID(), wsPropName.AsStringC());
   if (lpAttributeInfo) {
     (pObject->*(lpAttributeInfo->lpfnCallback))(
         pReturnValue, TRUE, (XFA_ATTRIBUTE)lpAttributeInfo->eAttribute);
   } else {
     if (pObject->IsNode()) {
       if (wsPropName.GetAt(0) == '#') {
         wsPropName = wsPropName.Right(wsPropName.GetLength() - 1);
       }
       CXFA_Node* pNode = ToNode(pObject);
-      CXFA_Node* pPropOrChild = NULL;
+      CXFA_Node* pPropOrChild = nullptr;
       const XFA_ELEMENTINFO* lpElementInfo =
           XFA_GetElementByName(wsPropName.AsStringC());
       if (lpElementInfo) {
         pPropOrChild = pNode->GetProperty(0, lpElementInfo->eName);
       } else {
         pPropOrChild = pNode->GetFirstChildByName(wsPropName.AsStringC());
       }
       if (pPropOrChild) {
         CFX_WideString wsDefaultName(L"{default}");
         const XFA_SCRIPTATTRIBUTEINFO* lpAttrInfo =
@@ skipping 72 matching lines @@
 
   (pObject->*(lpMethodInfo->lpfnCallback))(&args);
 }
 FX_BOOL CXFA_ScriptContext::IsStrictScopeInJavaScript() {
   return m_pDocument->HasFlag(XFA_DOCFLAG_StrictScoping);
 }
 XFA_SCRIPTLANGTYPE CXFA_ScriptContext::GetType() {
   return m_eScriptType;
 }
 void CXFA_ScriptContext::DefineJsContext() {
-  m_pJsContext = CFXJSE_Context::Create(m_pIsolate, &GlobalClassDescriptor,
-                                        m_pDocument->GetRoot());
-  RemoveBuiltInObjs(m_pJsContext);
-  m_pJsContext->EnableCompatibleMode();
+  m_JsContext.reset(CFXJSE_Context::Create(m_pIsolate, &GlobalClassDescriptor,
+                                           m_pDocument->GetRoot()));
+  RemoveBuiltInObjs(m_JsContext.get());
+  m_JsContext->EnableCompatibleMode();
 }
 CFXJSE_Context* CXFA_ScriptContext::CreateVariablesContext(
     CXFA_Node* pScriptNode,
     CXFA_Node* pSubform) {
   if (!pScriptNode || !pSubform)
     return nullptr;
 
   CFXJSE_Context* pVariablesContext =
       CFXJSE_Context::Create(m_pIsolate, &VariablesClassDescriptor,
                              new CXFA_ThisProxy(pSubform, pScriptNode));
@@ skipping 76 matching lines @@
       pValue->SetFunctionBind(hVariableValue.get(), pObject.get());
     else if (bGetter)
       pValue->Assign(hVariableValue.get());
     else
       hVariableValue.get()->Assign(pValue);
     bRes = TRUE;
   }
   return bRes;
 }
 
-void CXFA_ScriptContext::ReleaseVariablesMap() {
-  FX_POSITION ps = m_mapVariableToContext.GetStartPosition();
-  while (ps) {
-    CXFA_Object* pScriptNode;
-    CFXJSE_Context* pVariableContext = nullptr;
-    m_mapVariableToContext.GetNextAssoc(ps, pScriptNode, pVariableContext);
-
-    delete ToThisProxy(pVariableContext->GetGlobalObject().get(), nullptr);
-    delete pVariableContext;
-  }
-  m_mapVariableToContext.RemoveAll();
-}
-
 void CXFA_ScriptContext::DefineJsClass() {
-  m_pJsClass = CFXJSE_Class::Create(m_pJsContext, &NormalClassDescriptor);
+  m_pJsClass = CFXJSE_Class::Create(m_JsContext.get(), &NormalClassDescriptor);
 }
 
 void CXFA_ScriptContext::RemoveBuiltInObjs(CFXJSE_Context* pContext) const {
   static const CFX_ByteStringC OBJ_NAME[2] = {"Number", "Date"};
   std::unique_ptr<CFXJSE_Value> pObject = pContext->GetGlobalObject();
   std::unique_ptr<CFXJSE_Value> hProp(new CFXJSE_Value(m_pIsolate));
   for (int i = 0; i < 2; ++i) {
     if (pObject->GetObjectProperty(OBJ_NAME[i], hProp.get()))
       pObject->DeleteObjectProperty(OBJ_NAME[i]);
   }
@@ skipping 12 matching lines @@
   if (m_eScriptType != XFA_SCRIPTLANGTYPE_Formcalc ||
       (dwStyles & (XFA_RESOLVENODE_Parent | XFA_RESOLVENODE_Siblings))) {
     m_upObjectArray.RemoveAll();
   }
   if (refNode && refNode->IsNode() &&
       (dwStyles & (XFA_RESOLVENODE_Parent | XFA_RESOLVENODE_Siblings))) {
     m_upObjectArray.Add(refNode->AsNode());
   }
   FX_BOOL bNextCreate = FALSE;
   if (dwStyles & XFA_RESOLVENODE_CreateNode) {
-    m_pResolveProcessor->GetNodeHelper()->XFA_SetCreateNodeType(bindNode);
+    m_ResolveProcessor->GetNodeHelper()->XFA_SetCreateNodeType(bindNode);
   }
-  m_pResolveProcessor->GetNodeHelper()->m_pCreateParent = NULL;
-  m_pResolveProcessor->GetNodeHelper()->m_iCurAllStart = -1;
+  m_ResolveProcessor->GetNodeHelper()->m_pCreateParent = nullptr;
+  m_ResolveProcessor->GetNodeHelper()->m_iCurAllStart = -1;
   CXFA_ResolveNodesData rndFind;
   int32_t nStart = 0;
   int32_t nLevel = 0;
   int32_t nRet = -1;
   rndFind.m_pSC = this;
   CXFA_ObjArray findNodes;
   findNodes.Add(refNode ? refNode : m_pDocument->GetRoot());
   int32_t nNodes = 0;
   while (TRUE) {
     nNodes = findNodes.GetSize();
     int32_t i = 0;
     rndFind.m_dwStyles = dwStyles;
-    m_pResolveProcessor->m_iCurStart = nStart;
-    nStart = m_pResolveProcessor->XFA_ResolveNodes_GetFilter(wsExpression,
-                                                             nStart, rndFind);
+    m_ResolveProcessor->m_iCurStart = nStart;
+    nStart = m_ResolveProcessor->XFA_ResolveNodes_GetFilter(wsExpression,
+                                                            nStart, rndFind);
     if (nStart < 1) {
       if ((dwStyles & XFA_RESOLVENODE_CreateNode) && !bNextCreate) {
-        CXFA_Node* pDataNode = NULL;
-        nStart = m_pResolveProcessor->GetNodeHelper()->m_iCurAllStart;
+        CXFA_Node* pDataNode = nullptr;
+        nStart = m_ResolveProcessor->GetNodeHelper()->m_iCurAllStart;
         if (nStart != -1) {
           pDataNode = m_pDocument->GetNotBindNode(findNodes);
           if (pDataNode) {
             findNodes.RemoveAll();
             findNodes.Add(pDataNode);
             break;
           }
         } else {
           pDataNode = findNodes[0]->AsNode();
           findNodes.RemoveAll();
           findNodes.Add(pDataNode);
           break;
         }
         dwStyles |= XFA_RESOLVENODE_Bind;
         findNodes.RemoveAll();
-        findNodes.Add(m_pResolveProcessor->GetNodeHelper()->m_pAllStartParent);
+        findNodes.Add(m_ResolveProcessor->GetNodeHelper()->m_pAllStartParent);
         continue;
       } else {
         break;
       }
     }
     if (bNextCreate) {
       FX_BOOL bCreate =
-          m_pResolveProcessor->GetNodeHelper()->XFA_ResolveNodes_CreateNode(
+          m_ResolveProcessor->GetNodeHelper()->XFA_ResolveNodes_CreateNode(
               rndFind.m_wsName, rndFind.m_wsCondition,
               nStart == wsExpression.GetLength(), this);
       if (bCreate) {
         continue;
       } else {
         break;
       }
     }
     CXFA_ObjArray retNodes;
     while (i < nNodes) {
       FX_BOOL bDataBind = FALSE;
       if (((dwStyles & XFA_RESOLVENODE_Bind) ||
            (dwStyles & XFA_RESOLVENODE_CreateNode)) &&
           nNodes > 1) {
         CXFA_ResolveNodesData rndBind;
-        m_pResolveProcessor->XFA_ResolveNodes_GetFilter(wsExpression, nStart,
-                                                        rndBind);
-        m_pResolveProcessor->XFA_ResolveNode_SetIndexDataBind(
+        m_ResolveProcessor->XFA_ResolveNodes_GetFilter(wsExpression, nStart,
+                                                       rndBind);
+        m_ResolveProcessor->XFA_ResolveNode_SetIndexDataBind(
             rndBind.m_wsCondition, i, nNodes);
         bDataBind = TRUE;
       }
       rndFind.m_CurNode = findNodes[i++];
       rndFind.m_nLevel = nLevel;
       rndFind.m_dwFlag = XFA_RESOVENODE_RSTYPE_Nodes;
-      nRet = m_pResolveProcessor->XFA_ResolveNodes(rndFind);
+      nRet = m_ResolveProcessor->XFA_ResolveNodes(rndFind);
       if (nRet < 1) {
         continue;
       }
       if (rndFind.m_dwFlag == XFA_RESOVENODE_RSTYPE_Attribute &&
           rndFind.m_pScriptAttribute && nStart < wsExpression.GetLength()) {
         std::unique_ptr<CFXJSE_Value> pValue(new CFXJSE_Value(m_pIsolate));
         (rndFind.m_Nodes[0]->*(rndFind.m_pScriptAttribute->lpfnCallback))(
             pValue.get(), FALSE,
             (XFA_ATTRIBUTE)rndFind.m_pScriptAttribute->eAttribute);
         rndFind.m_Nodes.SetAt(0, ToObject(pValue.get(), nullptr));
       }
       int32_t iSize = m_upObjectArray.GetSize();
       if (iSize) {
         m_upObjectArray.RemoveAt(iSize - 1);
       }
       retNodes.Append(rndFind.m_Nodes);
       rndFind.m_Nodes.RemoveAll();
       if (bDataBind) {
         break;
       }
     }
     findNodes.RemoveAll();
     nNodes = retNodes.GetSize();
     if (nNodes < 1) {
       if (dwStyles & XFA_RESOLVENODE_CreateNode) {
         bNextCreate = TRUE;
-        if (m_pResolveProcessor->GetNodeHelper()->m_pCreateParent == NULL) {
-          m_pResolveProcessor->GetNodeHelper()->m_pCreateParent =
+        if (m_ResolveProcessor->GetNodeHelper()->m_pCreateParent == nullptr) {
+          m_ResolveProcessor->GetNodeHelper()->m_pCreateParent =
               ToNode(rndFind.m_CurNode);
-          m_pResolveProcessor->GetNodeHelper()->m_iCreateCount = 1;
+          m_ResolveProcessor->GetNodeHelper()->m_iCreateCount = 1;
         }
         FX_BOOL bCreate =
-            m_pResolveProcessor->GetNodeHelper()->XFA_ResolveNodes_CreateNode(
+            m_ResolveProcessor->GetNodeHelper()->XFA_ResolveNodes_CreateNode(
                 rndFind.m_wsName, rndFind.m_wsCondition,
                 nStart == wsExpression.GetLength(), this);
         if (bCreate) {
           continue;
         } else {
           break;
         }
       } else {
         break;
       }
@@ skipping 10 matching lines @@
     if (nNodes > 0) {
       resolveNodeRS.nodes.Append(findNodes);
     }
     if (rndFind.m_dwFlag == XFA_RESOVENODE_RSTYPE_Attribute) {
       resolveNodeRS.pScriptAttribute = rndFind.m_pScriptAttribute;
       return 1;
     }
   }
   if (dwStyles & (XFA_RESOLVENODE_CreateNode | XFA_RESOLVENODE_Bind |
                   XFA_RESOLVENODE_BindNew)) {
-    m_pResolveProcessor->XFA_ResolveNode_SetResultCreateNode(
+    m_ResolveProcessor->XFA_ResolveNode_SetResultCreateNode(
         resolveNodeRS, rndFind.m_wsCondition);
     if (!bNextCreate && (dwStyles & XFA_RESOLVENODE_CreateNode)) {
       resolveNodeRS.dwFlags = XFA_RESOVENODE_RSTYPE_ExistNodes;
     }
     return resolveNodeRS.nodes.GetSize();
   }
   return nNodes;
 }
 CFXJSE_Value* CXFA_ScriptContext::GetJSValueFromMap(CXFA_Object* pObject) {
   if (!pObject)
     return nullptr;
   if (pObject->IsNode())
     RunVariablesScript(pObject->AsNode());
 
-  void* pValue = m_mapXFAToValue.GetValueAt(pObject);
-  if (!pValue) {
-    CFXJSE_Value* jsValue = new CFXJSE_Value(m_pIsolate);
-    jsValue->SetObject(pObject, m_pJsClass);
-    m_mapXFAToValue.SetAt(pObject, jsValue);
-    pValue = jsValue;
-  }
-  return static_cast<CFXJSE_Value*>(pValue);
+  auto iter = m_mapObjectToValue.find(pObject);
+  if (iter != m_mapObjectToValue.end())
+    return iter->second.get();
+
+  std::unique_ptr<CFXJSE_Value> jsValue(new CFXJSE_Value(m_pIsolate));
+  jsValue->SetObject(pObject, m_pJsClass);
+  CFXJSE_Value* pValue = jsValue.get();
+  m_mapObjectToValue.insert(std::make_pair(pObject, std::move(jsValue)));
+  return pValue;
 }
 int32_t CXFA_ScriptContext::GetIndexByName(CXFA_Node* refNode) {
-  CXFA_NodeHelper* lpNodeHelper = m_pResolveProcessor->GetNodeHelper();
+  CXFA_NodeHelper* lpNodeHelper = m_ResolveProcessor->GetNodeHelper();
   return lpNodeHelper->XFA_GetIndex(refNode, XFA_LOGIC_Transparent,
                                     lpNodeHelper->XFA_NodeIsProperty(refNode),
                                     FALSE);
 }
 int32_t CXFA_ScriptContext::GetIndexByClassName(CXFA_Node* refNode) {
-  CXFA_NodeHelper* lpNodeHelper = m_pResolveProcessor->GetNodeHelper();
+  CXFA_NodeHelper* lpNodeHelper = m_ResolveProcessor->GetNodeHelper();
   return lpNodeHelper->XFA_GetIndex(refNode, XFA_LOGIC_Transparent,
                                     lpNodeHelper->XFA_NodeIsProperty(refNode),
                                     TRUE);
 }
 void CXFA_ScriptContext::GetSomExpression(CXFA_Node* refNode,
                                           CFX_WideString& wsExpression) {
-  CXFA_NodeHelper* lpNodeHelper = m_pResolveProcessor->GetNodeHelper();
+  CXFA_NodeHelper* lpNodeHelper = m_ResolveProcessor->GetNodeHelper();
   lpNodeHelper->XFA_GetNameExpression(refNode, wsExpression, TRUE,
                                       XFA_LOGIC_Transparent);
 }
 void CXFA_ScriptContext::SetNodesOfRunScript(CXFA_NodeArray* pArray) {
   m_pScriptNodeArray = pArray;
 }
 void CXFA_ScriptContext::AddNodesOfRunScript(const CXFA_NodeArray& nodes) {
-  if (!m_pScriptNodeArray) {
+  if (!m_pScriptNodeArray)
     return;
-  }
-  if (nodes.GetSize() > 0) {
+  if (nodes.GetSize() > 0)
     m_pScriptNodeArray->Copy(nodes);
-  }
 }
 void CXFA_ScriptContext::AddNodesOfRunScript(CXFA_Node* pNode) {
-  if (!m_pScriptNodeArray) {
+  if (!m_pScriptNodeArray)
     return;
-  }
-  if (m_pScriptNodeArray->Find(pNode) == -1) {
+  if (m_pScriptNodeArray->Find(pNode) == -1)
     m_pScriptNodeArray->Add(pNode);
-  }
 }