Remove FXJSE_HOBJECT and FXJSE_HVALUE for CFXJSE_Value*

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 "xfa/fxfa/app/xfa_ffnotify.h"
 #include "xfa/fxfa/fm2js/xfa_fm2jsapi.h"
 #include "xfa/fxfa/parser/xfa_doclayout.h"
 #include "xfa/fxfa/parser/xfa_document.h"
 #include "xfa/fxfa/parser/xfa_localemgr.h"
 #include "xfa/fxfa/parser/xfa_object.h"
 #include "xfa/fxfa/parser/xfa_parser.h"
 #include "xfa/fxfa/parser/xfa_script.h"
 #include "xfa/fxfa/parser/xfa_script_nodehelper.h"
 #include "xfa/fxfa/parser/xfa_script_resolveprocessor.h"
 #include "xfa/fxfa/parser/xfa_utils.h"
 #include "xfa/fxjse/cfxjse_arguments.h"
+#include "xfa/fxjse/value.h"
 
 CXFA_ScriptContext::CXFA_ScriptContext(CXFA_Document* pDocument)
     : m_pDocument(pDocument),
       m_pJsContext(nullptr),
       m_pIsolate(nullptr),
       m_pJsClass(nullptr),
       m_eScriptType(XFA_SCRIPTLANGTYPE_Unkown),
       m_pScriptNodeArray(nullptr),
       m_pResolveProcessor(nullptr),
       m_hFM2JSContext(nullptr),
       m_pThisObject(nullptr),
       m_dwBuiltInInFlags(0),
       m_eRunAtType(XFA_ATTRIBUTEENUM_Client) {
   FXSYS_memset(&m_JsGlobalClass, 0, sizeof(FXJSE_CLASS));
   FXSYS_memset(&m_JsNormalClass, 0, sizeof(FXJSE_CLASS));
 }
 CXFA_ScriptContext::~CXFA_ScriptContext() {
-  FX_POSITION ps = m_mapXFAToHValue.GetStartPosition();
+  FX_POSITION ps = m_mapXFAToValue.GetStartPosition();
   while (ps) {
     CXFA_Object* pXFAObj;
-    FXJSE_HVALUE pValue;
-    m_mapXFAToHValue.GetNextAssoc(ps, pXFAObj, pValue);
+    CFXJSE_Value* pValue;
+    m_mapXFAToValue.GetNextAssoc(ps, pXFAObj, pValue);
     FXJSE_Value_Release(pValue);
   }
-  m_mapXFAToHValue.RemoveAll();
+  m_mapXFAToValue.RemoveAll();
   ReleaseVariablesMap();
   if (m_hFM2JSContext) {
     XFA_FM2JS_ContextRelease(m_hFM2JSContext);
     m_hFM2JSContext = NULL;
   }
   if (m_pJsContext) {
     FXJSE_Context_Release(m_pJsContext);
     m_pJsContext = NULL;
   }
   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;
 }
 FX_BOOL CXFA_ScriptContext::RunScript(XFA_SCRIPTLANGTYPE eScriptType,
                                       const CFX_WideStringC& wsScript,
-                                      FXJSE_HVALUE hRetValue,
+                                      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 = XFA_FM2JS_ContextCreate();
       XFA_FM2JS_ContextInitialize(m_hFM2JSContext, m_pIsolate, m_pJsContext,
                                   m_pDocument);
     }
     CFX_WideTextBuf wsJavaScript;
     CFX_WideString wsErrorInfo;
     int32_t iFlags = XFA_FM2JS_Translate(wsScript, wsJavaScript, wsErrorInfo);
     if (iFlags) {
       FXJSE_Value_SetUndefined(hRetValue);
       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;
-  FXJSE_HVALUE pValue = pThisObject ? GetJSValueFromMap(pThisObject) : NULL;
+  CFXJSE_Value* pValue = pThisObject ? GetJSValueFromMap(pThisObject) : NULL;
   FX_BOOL bRet =
       FXJSE_ExecuteScript(m_pJsContext, btScript.c_str(), hRetValue, pValue);
   m_pThisObject = pOriginalObject;
   m_eScriptType = eSaveType;
   return bRet;
 }
-void CXFA_ScriptContext::GlobalPropertySetter(FXJSE_HOBJECT hObject,
+void CXFA_ScriptContext::GlobalPropertySetter(CFXJSE_Value* pObject,
                                               const CFX_ByteStringC& szPropName,
-                                              FXJSE_HVALUE hValue) {
-  CXFA_Object* lpOrginalNode = (CXFA_Object*)FXJSE_Value_ToObject(hObject);
+                                              CFXJSE_Value* pValue) {
+  CXFA_Object* lpOrginalNode = (CXFA_Object*)FXJSE_Value_ToObject(pObject);
   CXFA_Document* pDoc = lpOrginalNode->GetDocument();
   CXFA_ScriptContext* lpScriptContext =
       (CXFA_ScriptContext*)pDoc->GetScriptContext();
   CXFA_Object* lpCurNode = lpScriptContext->GetVariablesThis(lpOrginalNode);
   CFX_WideString wsPropName = CFX_WideString::FromUTF8(szPropName);
   uint32_t dwFlag = XFA_RESOLVENODE_Parent | XFA_RESOLVENODE_Siblings |
                     XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Properties |
                     XFA_RESOLVENODE_Attributes;
   CXFA_Node* pRefNode = ToNode(lpScriptContext->GetThisObject());
   if (lpOrginalNode->GetObjectType() == XFA_OBJECTTYPE_VariablesThis) {
     pRefNode = ToNode(lpCurNode);
   }
-  if (lpScriptContext->QueryNodeByFlag(pRefNode, wsPropName.AsStringC(), hValue,
+  if (lpScriptContext->QueryNodeByFlag(pRefNode, wsPropName.AsStringC(), pValue,
                                        dwFlag, TRUE)) {
     return;
   }
   if (lpOrginalNode->GetObjectType() == XFA_OBJECTTYPE_VariablesThis) {
-    if (FXJSE_Value_IsUndefined(hValue)) {
-      FXJSE_Value_SetObjectOwnProp(hObject, szPropName, hValue);
+    if (FXJSE_Value_IsUndefined(pValue)) {
+      FXJSE_Value_SetObjectOwnProp(pObject, szPropName, pValue);
       return;
     }
   }
   CXFA_FFNotify* pNotify = pDoc->GetNotify();
   if (!pNotify) {
     return;
   }
   pNotify->GetDocProvider()->SetGlobalProperty(pNotify->GetHDOC(), szPropName,
-                                               hValue);
+                                               pValue);
 }
 FX_BOOL CXFA_ScriptContext::QueryNodeByFlag(CXFA_Node* refNode,
                                             const CFX_WideStringC& propname,
-                                            FXJSE_HVALUE hValue,
+                                            CFXJSE_Value* pValue,
                                             uint32_t dwFlag,
                                             FX_BOOL bSetting) {
   if (!refNode)
     return false;
   XFA_RESOLVENODE_RS resolveRs;
   if (ResolveObjects(refNode, propname, resolveRs, dwFlag) <= 0)
     return false;
   if (resolveRs.dwFlags == XFA_RESOVENODE_RSTYPE_Nodes) {
-    FXJSE_HVALUE pValue = GetJSValueFromMap(resolveRs.nodes[0]);
-    FXJSE_Value_Set(hValue, pValue);
+    CFXJSE_Value* pValue = GetJSValueFromMap(resolveRs.nodes[0]);
+    FXJSE_Value_Set(pValue, pValue);
     return true;
   }
   if (resolveRs.dwFlags == XFA_RESOVENODE_RSTYPE_Attribute) {
     const XFA_SCRIPTATTRIBUTEINFO* lpAttributeInfo = resolveRs.pScriptAttribute;
     if (lpAttributeInfo) {
       (resolveRs.nodes[0]->*(lpAttributeInfo->lpfnCallback))(
-          hValue, bSetting, (XFA_ATTRIBUTE)lpAttributeInfo->eAttribute);
+          pValue, bSetting, (XFA_ATTRIBUTE)lpAttributeInfo->eAttribute);
     }
   }
   return true;
 }
-void CXFA_ScriptContext::GlobalPropertyGetter(FXJSE_HOBJECT hObject,
+void CXFA_ScriptContext::GlobalPropertyGetter(CFXJSE_Value* pObject,
                                               const CFX_ByteStringC& szPropName,
-                                              FXJSE_HVALUE hValue) {
-  CXFA_Object* pOrginalObject = (CXFA_Object*)FXJSE_Value_ToObject(hObject);
-  CXFA_Document* pDoc = pOrginalObject->GetDocument();
+                                              CFXJSE_Value* pValue) {
+  CXFA_Object* pOriginalObject = (CXFA_Object*)FXJSE_Value_ToObject(pObject);
+  CXFA_Document* pDoc = pOriginalObject->GetDocument();
   CXFA_ScriptContext* lpScriptContext =
       (CXFA_ScriptContext*)pDoc->GetScriptContext();
-  CXFA_Object* lpCurNode = lpScriptContext->GetVariablesThis(pOrginalObject);
+  CXFA_Object* lpCurNode = lpScriptContext->GetVariablesThis(pOriginalObject);
   CFX_WideString wsPropName = CFX_WideString::FromUTF8(szPropName);
   if (lpScriptContext->GetType() == XFA_SCRIPTLANGTYPE_Formcalc) {
     if (szPropName == FOXIT_XFA_FM2JS_FORMCALC_RUNTIME) {
-      XFA_FM2JS_GlobalPropertyGetter(lpScriptContext->m_hFM2JSContext, hValue);
+      XFA_FM2JS_GlobalPropertyGetter(lpScriptContext->m_hFM2JSContext, pValue);
       return;
     }
     XFA_HashCode uHashCode = static_cast<XFA_HashCode>(
         FX_HashCode_GetW(wsPropName.AsStringC(), false));
     if (uHashCode != XFA_HASHCODE_Layout) {
       CXFA_Object* pObject =
           lpScriptContext->GetDocument()->GetXFAObject(uHashCode);
       if (pObject) {
-        FXJSE_Value_Set(hValue, lpScriptContext->GetJSValueFromMap(pObject));
+        FXJSE_Value_Set(pValue, lpScriptContext->GetJSValueFromMap(pObject));
         return;
       }
     }
   }
   uint32_t dwFlag = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Properties |
                     XFA_RESOLVENODE_Attributes;
   CXFA_Node* pRefNode = ToNode(lpScriptContext->GetThisObject());
-  if (pOrginalObject->GetObjectType() == XFA_OBJECTTYPE_VariablesThis) {
+  if (pOriginalObject->GetObjectType() == XFA_OBJECTTYPE_VariablesThis) {
     pRefNode = ToNode(lpCurNode);
   }
-  if (lpScriptContext->QueryNodeByFlag(pRefNode, wsPropName.AsStringC(), hValue,
+  if (lpScriptContext->QueryNodeByFlag(pRefNode, wsPropName.AsStringC(), pValue,
                                        dwFlag, FALSE)) {
     return;
   }
   dwFlag = XFA_RESOLVENODE_Parent | XFA_RESOLVENODE_Siblings;
-  if (lpScriptContext->QueryNodeByFlag(pRefNode, wsPropName.AsStringC(), hValue,
+  if (lpScriptContext->QueryNodeByFlag(pRefNode, wsPropName.AsStringC(), pValue,
                                        dwFlag, FALSE)) {
     return;
   }
   CXFA_Object* pScriptObject =
-      lpScriptContext->GetVariablesThis(pOrginalObject, TRUE);
+      lpScriptContext->GetVariablesThis(pOriginalObject, TRUE);
   if (pScriptObject &&
-      lpScriptContext->QueryVariableHValue(pScriptObject->AsNode(), szPropName,
-                                           hValue, TRUE)) {
+      lpScriptContext->QueryVariableValue(pScriptObject->AsNode(), szPropName,
+                                          pValue, TRUE)) {
     return;
   }
   CXFA_FFNotify* pNotify = pDoc->GetNotify();
   if (!pNotify) {
     return;
   }
   pNotify->GetDocProvider()->GetGlobalProperty(pNotify->GetHDOC(), szPropName,
-                                               hValue);
+                                               pValue);
 }
-void CXFA_ScriptContext::NormalPropertyGetter(FXJSE_HOBJECT hObject,
+void CXFA_ScriptContext::NormalPropertyGetter(CFXJSE_Value* pOriginalValue,
                                               const CFX_ByteStringC& szPropName,
-                                              FXJSE_HVALUE hValue) {
-  CXFA_Object* pOrginalObject = (CXFA_Object*)FXJSE_Value_ToObject(hObject);
-  if (pOrginalObject == NULL) {
-    FXJSE_Value_SetUndefined(hValue);
+                                              CFXJSE_Value* pReturnValue) {
+  CXFA_Object* pOriginalObject =
+      (CXFA_Object*)FXJSE_Value_ToObject(pOriginalValue);
+  if (!pOriginalObject) {
+    FXJSE_Value_SetUndefined(pReturnValue);
     return;
   }
   CFX_WideString wsPropName = CFX_WideString::FromUTF8(szPropName);
   CXFA_ScriptContext* lpScriptContext =
-      (CXFA_ScriptContext*)pOrginalObject->GetDocument()->GetScriptContext();

[Tom Sepez, 2016/05/26 15:51:57]

nice.

-  CXFA_Object* pObject = lpScriptContext->GetVariablesThis(pOrginalObject);
+      (CXFA_ScriptContext*)pOriginalObject->GetDocument()->GetScriptContext();
+  CXFA_Object* pObject = lpScriptContext->GetVariablesThis(pOriginalObject);
   if (wsPropName == FX_WSTRC(L"xfa")) {
-    FXJSE_HVALUE pValue = lpScriptContext->GetJSValueFromMap(
+    CFXJSE_Value* pValue = lpScriptContext->GetJSValueFromMap(
         lpScriptContext->GetDocument()->GetRoot());
-    FXJSE_Value_Set(hValue, pValue);
+    FXJSE_Value_Set(pReturnValue, pValue);
     return;
   }
   uint32_t dwFlag = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Properties |
                     XFA_RESOLVENODE_Attributes;
   FX_BOOL bRet = lpScriptContext->QueryNodeByFlag(
-      ToNode(pObject), wsPropName.AsStringC(), hValue, dwFlag, FALSE);
+      ToNode(pObject), wsPropName.AsStringC(), pReturnValue, dwFlag, FALSE);
   if (bRet) {
     return;
   }
   if (pObject == lpScriptContext->GetThisObject() ||
       (lpScriptContext->GetType() == XFA_SCRIPTLANGTYPE_Javascript &&
        !lpScriptContext->IsStrictScopeInJavaScript())) {
     dwFlag = XFA_RESOLVENODE_Parent | XFA_RESOLVENODE_Siblings;
     bRet = lpScriptContext->QueryNodeByFlag(
-        ToNode(pObject), wsPropName.AsStringC(), hValue, dwFlag, FALSE);
+        ToNode(pObject), wsPropName.AsStringC(), pReturnValue, dwFlag, FALSE);
   }
   if (bRet) {
     return;
   }
   CXFA_Object* pScriptObject =
-      lpScriptContext->GetVariablesThis(pOrginalObject, TRUE);
+      lpScriptContext->GetVariablesThis(pOriginalObject, TRUE);
   if (pScriptObject) {
-    bRet = lpScriptContext->QueryVariableHValue(ToNode(pScriptObject),
-                                                szPropName, hValue, TRUE);
+    bRet = lpScriptContext->QueryVariableValue(ToNode(pScriptObject),
+                                               szPropName, pReturnValue, TRUE);
   }
   if (!bRet) {
-    FXJSE_Value_SetUndefined(hValue);
+    FXJSE_Value_SetUndefined(pReturnValue);
   }
 }
-void CXFA_ScriptContext::NormalPropertySetter(FXJSE_HOBJECT hObject,
+void CXFA_ScriptContext::NormalPropertySetter(CFXJSE_Value* pOriginalValue,
                                               const CFX_ByteStringC& szPropName,
-                                              FXJSE_HVALUE hValue) {
-  CXFA_Object* pOrginalObject = (CXFA_Object*)FXJSE_Value_ToObject(hObject);
-  if (pOrginalObject == NULL) {
+                                              CFXJSE_Value* pReturnValue) {
+  CXFA_Object* pOriginalObject =
+      (CXFA_Object*)FXJSE_Value_ToObject(pOriginalValue);
+  if (!pOriginalObject)
     return;
-  }
+
   CXFA_ScriptContext* lpScriptContext =
-      (CXFA_ScriptContext*)pOrginalObject->GetDocument()->GetScriptContext();
-  CXFA_Object* pObject = lpScriptContext->GetVariablesThis(pOrginalObject);
+      (CXFA_ScriptContext*)pOriginalObject->GetDocument()->GetScriptContext();
+  CXFA_Object* pObject = lpScriptContext->GetVariablesThis(pOriginalObject);
   CFX_WideString wsPropName = CFX_WideString::FromUTF8(szPropName);
   const XFA_SCRIPTATTRIBUTEINFO* lpAttributeInfo = XFA_GetScriptAttributeByName(
       pObject->GetClassID(), wsPropName.AsStringC());
   if (lpAttributeInfo) {
     (pObject->*(lpAttributeInfo->lpfnCallback))(
-        hValue, TRUE, (XFA_ATTRIBUTE)lpAttributeInfo->eAttribute);
+        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;
       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* lpAttributeInfo =
             XFA_GetScriptAttributeByName(pPropOrChild->GetClassID(),
                                          wsDefaultName.AsStringC());
         if (lpAttributeInfo) {
           (pPropOrChild->*(lpAttributeInfo->lpfnCallback))(
-              hValue, TRUE, (XFA_ATTRIBUTE)lpAttributeInfo->eAttribute);
+              pReturnValue, TRUE, (XFA_ATTRIBUTE)lpAttributeInfo->eAttribute);
           return;
         }
       }
     }
     CXFA_Object* pScriptObject =
-        lpScriptContext->GetVariablesThis(pOrginalObject, TRUE);
+        lpScriptContext->GetVariablesThis(pOriginalObject, TRUE);
     if (pScriptObject) {
-      lpScriptContext->QueryVariableHValue(ToNode(pScriptObject), szPropName,
-                                           hValue, FALSE);
+      lpScriptContext->QueryVariableValue(ToNode(pScriptObject), szPropName,
+                                          pReturnValue, FALSE);
     }
   }
 }
 int32_t CXFA_ScriptContext::NormalPropTypeGetter(
-    FXJSE_HOBJECT hObject,
+    CFXJSE_Value* pOriginalValue,
     const CFX_ByteStringC& szPropName,
     FX_BOOL bQueryIn) {
-  CXFA_Object* pObject = (CXFA_Object*)FXJSE_Value_ToObject(hObject);
-  if (pObject == NULL) {
+  CXFA_Object* pObject = (CXFA_Object*)FXJSE_Value_ToObject(pOriginalValue);
+  if (!pObject)
     return FXJSE_ClassPropType_None;
-  }
+
   CXFA_ScriptContext* lpScriptContext =
       (CXFA_ScriptContext*)pObject->GetDocument()->GetScriptContext();
   pObject = lpScriptContext->GetVariablesThis(pObject);
   XFA_ELEMENT objElement = pObject->GetClassID();
   CFX_WideString wsPropName = CFX_WideString::FromUTF8(szPropName);
   if (XFA_GetMethodByName(objElement, wsPropName.AsStringC())) {
     return FXJSE_ClassPropType_Method;
   }
   if (bQueryIn &&
       !XFA_GetScriptAttributeByName(objElement, wsPropName.AsStringC())) {
     return FXJSE_ClassPropType_None;
   }
   return FXJSE_ClassPropType_Property;
 }
 int32_t CXFA_ScriptContext::GlobalPropTypeGetter(
-    FXJSE_HOBJECT hObject,
+    CFXJSE_Value* pOriginalValue,
     const CFX_ByteStringC& szPropName,
     FX_BOOL bQueryIn) {
-  CXFA_Object* pObject = (CXFA_Object*)FXJSE_Value_ToObject(hObject);
-  if (pObject == NULL) {
+  CXFA_Object* pObject = (CXFA_Object*)FXJSE_Value_ToObject(pOriginalValue);
+  if (!pObject)
     return FXJSE_ClassPropType_None;
-  }
+
   CXFA_ScriptContext* lpScriptContext =
       (CXFA_ScriptContext*)pObject->GetDocument()->GetScriptContext();
   pObject = lpScriptContext->GetVariablesThis(pObject);
   XFA_ELEMENT objElement = pObject->GetClassID();
   CFX_WideString wsPropName = CFX_WideString::FromUTF8(szPropName);
   if (XFA_GetMethodByName(objElement, wsPropName.AsStringC())) {
     return FXJSE_ClassPropType_Method;
   }
   return FXJSE_ClassPropType_Property;
 }
-void CXFA_ScriptContext::NormalMethodCall(FXJSE_HOBJECT hThis,
+void CXFA_ScriptContext::NormalMethodCall(CFXJSE_Value* pThis,
                                           const CFX_ByteStringC& szFuncName,
                                           CFXJSE_Arguments& args) {
-  CXFA_Object* pObject = (CXFA_Object*)FXJSE_Value_ToObject(hThis);
-  if (pObject == NULL) {
+  CXFA_Object* pObject = (CXFA_Object*)FXJSE_Value_ToObject(pThis);
+  if (!pObject)
     return;
-  }
+
   CXFA_ScriptContext* lpScriptContext =
       (CXFA_ScriptContext*)pObject->GetDocument()->GetScriptContext();
   pObject = lpScriptContext->GetVariablesThis(pObject);
   CFX_WideString wsFunName = CFX_WideString::FromUTF8(szFuncName);
   const XFA_METHODINFO* lpMethodInfo =
       XFA_GetMethodByName(pObject->GetClassID(), wsFunName.AsStringC());
-  if (NULL == lpMethodInfo) {
+  if (!lpMethodInfo)
     return;
-  }
+
   (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_JsGlobalClass.constructor = NULL;
@@ skipping 71 matching lines @@
   CXFA_Node* pTextNode = pScriptNode->GetNodeItem(XFA_NODEITEM_FirstChild);
   if (!pTextNode)
     return FALSE;
 
   CFX_WideStringC wsScript;
   if (!pTextNode->TryCData(XFA_ATTRIBUTE_Value, wsScript))
     return FALSE;
 
   CFX_ByteString btScript =
       FX_UTF8Encode(wsScript.c_str(), wsScript.GetLength());
-  FXJSE_HVALUE hRetValue = FXJSE_Value_Create(m_pIsolate);
+  CFXJSE_Value* hRetValue = FXJSE_Value_Create(m_pIsolate);
   CXFA_Node* pThisObject = pParent->GetNodeItem(XFA_NODEITEM_Parent);
   CFXJSE_Context* pVariablesContext =
       CreateVariablesContext(pScriptNode, pThisObject);
   CXFA_Object* pOriginalObject = m_pThisObject;
   m_pThisObject = pThisObject;
   FX_BOOL bRet =
       FXJSE_ExecuteScript(pVariablesContext, btScript.c_str(), hRetValue);
   m_pThisObject = pOriginalObject;
   FXJSE_Value_Release(hRetValue);
   return bRet;
 }
 
-FX_BOOL CXFA_ScriptContext::QueryVariableHValue(
+FX_BOOL CXFA_ScriptContext::QueryVariableValue(
     CXFA_Node* pScriptNode,
     const CFX_ByteStringC& szPropName,
-    FXJSE_HVALUE hValue,
+    CFXJSE_Value* pValue,
     FX_BOOL bGetter) {
   if (!pScriptNode || pScriptNode->GetClassID() != XFA_ELEMENT_Script)
     return FALSE;
 
   CXFA_Node* variablesNode = pScriptNode->GetNodeItem(XFA_NODEITEM_Parent);
   if (!variablesNode || variablesNode->GetClassID() != XFA_ELEMENT_Variables)
     return FALSE;
 
   void* lpVariables = m_mapVariableToContext.GetValueAt(pScriptNode);
   if (!lpVariables)
     return FALSE;
 
   FX_BOOL bRes = FALSE;
   CFXJSE_Context* pVariableContext = static_cast<CFXJSE_Context*>(lpVariables);
-  FXJSE_HVALUE hObject = FXJSE_Context_GetGlobalObject(pVariableContext);
-  FXJSE_HVALUE hVariableValue = FXJSE_Value_Create(m_pIsolate);
+  CFXJSE_Value* pObject = FXJSE_Context_GetGlobalObject(pVariableContext);
+  CFXJSE_Value* hVariableValue = FXJSE_Value_Create(m_pIsolate);
   if (!bGetter) {
-    FXJSE_Value_SetObjectOwnProp(hObject, szPropName, hValue);
+    FXJSE_Value_SetObjectOwnProp(pObject, szPropName, pValue);
     bRes = TRUE;
-  } else if (FXJSE_Value_ObjectHasOwnProp(hObject, szPropName, FALSE)) {
-    FXJSE_Value_GetObjectProp(hObject, szPropName, hVariableValue);
+  } else if (FXJSE_Value_ObjectHasOwnProp(pObject, szPropName, FALSE)) {
+    FXJSE_Value_GetObjectProp(pObject, szPropName, hVariableValue);
     if (FXJSE_Value_IsFunction(hVariableValue))
-      FXJSE_Value_SetFunctionBind(hValue, hVariableValue, hObject);
+      FXJSE_Value_SetFunctionBind(pValue, hVariableValue, pObject);
     else if (bGetter)
-      FXJSE_Value_Set(hValue, hVariableValue);
+      FXJSE_Value_Set(pValue, hVariableValue);
     else
-      FXJSE_Value_Set(hVariableValue, hValue);
+      FXJSE_Value_Set(hVariableValue, pValue);
     bRes = TRUE;
   }
   FXJSE_Value_Release(hVariableValue);
-  FXJSE_Value_Release(hObject);
+  FXJSE_Value_Release(pObject);
   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);
-    FXJSE_HVALUE hObject = FXJSE_Context_GetGlobalObject(pVariableContext);
-    delete static_cast<CXFA_ThisProxy*>(FXJSE_Value_ToObject(hObject));
-    FXJSE_Value_Release(hObject);
+    CFXJSE_Value* pObject = FXJSE_Context_GetGlobalObject(pVariableContext);
+    delete static_cast<CXFA_ThisProxy*>(FXJSE_Value_ToObject(pObject));
+    FXJSE_Value_Release(pObject);
     FXJSE_Context_Release(pVariableContext);
   }
   m_mapVariableToContext.RemoveAll();
 }
 
 void CXFA_ScriptContext::DefineJsClass() {
   m_JsNormalClass.constructor = NULL;
   m_JsNormalClass.name = "XFAObject";
   m_JsNormalClass.propNum = 0;
   m_JsNormalClass.properties = NULL;
   m_JsNormalClass.methNum = 0;
   m_JsNormalClass.methods = NULL;
   m_JsNormalClass.dynPropGetter = CXFA_ScriptContext::NormalPropertyGetter;
   m_JsNormalClass.dynPropSetter = CXFA_ScriptContext::NormalPropertySetter;
   m_JsNormalClass.dynPropTypeGetter = CXFA_ScriptContext::NormalPropTypeGetter;
   m_JsNormalClass.dynPropDeleter = NULL;
   m_JsNormalClass.dynMethodCall = CXFA_ScriptContext::NormalMethodCall;
   m_pJsClass = FXJSE_DefineClass(m_pJsContext, &m_JsNormalClass);
 }
 void CXFA_ScriptContext::RemoveBuiltInObjs(CFXJSE_Context* pContext) const {
   static const CFX_ByteStringC OBJ_NAME[2] = {"Number", "Date"};
-  FXJSE_HVALUE hObject = FXJSE_Context_GetGlobalObject(pContext);
-  FXJSE_HVALUE hProp = FXJSE_Value_Create(m_pIsolate);
+  CFXJSE_Value* pObject = FXJSE_Context_GetGlobalObject(pContext);
+  CFXJSE_Value* hProp = FXJSE_Value_Create(m_pIsolate);
   for (int i = 0; i < 2; ++i) {
-    if (FXJSE_Value_GetObjectProp(hObject, OBJ_NAME[i], hProp))
-      FXJSE_Value_DeleteObjectProp(hObject, OBJ_NAME[i]);
+    if (FXJSE_Value_GetObjectProp(pObject, OBJ_NAME[i], hProp))
+      FXJSE_Value_DeleteObjectProp(pObject, OBJ_NAME[i]);
   }
   FXJSE_Value_Release(hProp);
-  FXJSE_Value_Release(hObject);
+  FXJSE_Value_Release(pObject);
 }
 CFXJSE_Class* CXFA_ScriptContext::GetJseNormalClass() {
   return m_pJsClass;
 }
 int32_t CXFA_ScriptContext::ResolveObjects(CXFA_Object* refNode,
                                            const CFX_WideStringC& wsExpression,
                                            XFA_RESOLVENODE_RS& resolveNodeRS,
                                            uint32_t dwStyles,
                                            CXFA_Node* bindNode) {
   if (wsExpression.IsEmpty()) {
@@ skipping 79 matching lines @@
       }
       rndFind.m_CurNode = findNodes[i++];
       rndFind.m_nLevel = nLevel;
       rndFind.m_dwFlag = XFA_RESOVENODE_RSTYPE_Nodes;
       nRet = m_pResolveProcessor->XFA_ResolveNodes(rndFind);
       if (nRet < 1) {
         continue;
       }
       if (rndFind.m_dwFlag == XFA_RESOVENODE_RSTYPE_Attribute &&
           rndFind.m_pScriptAttribute && nStart < wsExpression.GetLength()) {
-        FXJSE_HVALUE hValue = FXJSE_Value_Create(m_pIsolate);
+        CFXJSE_Value* pValue = FXJSE_Value_Create(m_pIsolate);
         (rndFind.m_Nodes[0]->*(rndFind.m_pScriptAttribute->lpfnCallback))(
-            hValue, FALSE,
+            pValue, FALSE,
             (XFA_ATTRIBUTE)rndFind.m_pScriptAttribute->eAttribute);
-        rndFind.m_Nodes.SetAt(0, (CXFA_Object*)FXJSE_Value_ToObject(hValue));
-        FXJSE_Value_Release(hValue);
+        rndFind.m_Nodes.SetAt(0, (CXFA_Object*)FXJSE_Value_ToObject(pValue));
+        FXJSE_Value_Release(pValue);
       }
       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;
       }
@@ skipping 42 matching lines @@
                   XFA_RESOLVENODE_BindNew)) {
     m_pResolveProcessor->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;
 }
-FXJSE_HVALUE CXFA_ScriptContext::GetJSValueFromMap(CXFA_Object* pObject) {
-  if (!pObject) {
-    return NULL;
+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 = FXJSE_Value_Create(m_pIsolate);
+    FXJSE_Value_SetObject(jsValue, pObject, m_pJsClass);
+    m_mapXFAToValue.SetAt(pObject, jsValue);
+    pValue = jsValue;
   }
-  if (pObject->IsNode()) {
-    RunVariablesScript(pObject->AsNode());
-  }
-  void* pValue = m_mapXFAToHValue.GetValueAt(pObject);
-  if (pValue == NULL) {
-    FXJSE_HVALUE jsHvalue = FXJSE_Value_Create(m_pIsolate);
-    FXJSE_Value_SetObject(jsHvalue, pObject, m_pJsClass);
-    m_mapXFAToHValue.SetAt(pObject, jsHvalue);
-    pValue = jsHvalue;
-  }
-  return (FXJSE_HVALUE)pValue;
+  return static_cast<CFXJSE_Value*>(pValue);
 }
 int32_t CXFA_ScriptContext::GetIndexByName(CXFA_Node* refNode) {
   CXFA_NodeHelper* lpNodeHelper = m_pResolveProcessor->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();
   return lpNodeHelper->XFA_GetIndex(refNode, XFA_LOGIC_Transparent,
@@ skipping 18 matching lines @@
   }
 }
 void CXFA_ScriptContext::AddNodesOfRunScript(CXFA_Node* pNode) {
   if (!m_pScriptNodeArray) {
     return;
   }
   if (m_pScriptNodeArray->Find(pNode) == -1) {
     m_pScriptNodeArray->Add(pNode);
   }
 }