Remove various FXJSE Value methods.

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"
@@ skipping 119 matching lines @@
   if (eScriptType == XFA_SCRIPTLANGTYPE_Formcalc) {
     if (!m_hFM2JSContext) {
       m_hFM2JSContext =
           new CXFA_FM2JSContext(m_pIsolate, m_pJsContext, m_pDocument);
     }
     CFX_WideTextBuf wsJavaScript;
     CFX_WideString wsErrorInfo;
     int32_t iFlags =
         CXFA_FM2JSContext::Translate(wsScript, wsJavaScript, wsErrorInfo);
     if (iFlags) {
-      FXJSE_Value_SetUndefined(hRetValue);
+      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;
@@ skipping 17 matching lines @@
   CXFA_Node* pRefNode = ToNode(lpScriptContext->GetThisObject());
   if (lpOrginalNode->GetObjectType() == XFA_OBJECTTYPE_VariablesThis) {
     pRefNode = ToNode(lpCurNode);
   }
   if (lpScriptContext->QueryNodeByFlag(pRefNode, wsPropName.AsStringC(), pValue,
                                        dwFlag, TRUE)) {
     return;
   }
   if (lpOrginalNode->GetObjectType() == XFA_OBJECTTYPE_VariablesThis) {
     if (FXJSE_Value_IsUndefined(pValue)) {
-      FXJSE_Value_SetObjectOwnProp(pObject, szPropName, pValue);
+      pObject->SetObjectOwnProperty(szPropName, pValue);
       return;
     }
   }
   CXFA_FFNotify* pNotify = pDoc->GetNotify();
   if (!pNotify) {
     return;
   }
   pNotify->GetDocProvider()->SetGlobalProperty(pNotify->GetHDOC(), szPropName,
                                                pValue);
 }
 FX_BOOL CXFA_ScriptContext::QueryNodeByFlag(CXFA_Node* refNode,
                                             const CFX_WideStringC& propname,
                                             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_Value_Set(pValue, GetJSValueFromMap(resolveRs.nodes[0]));
+    pValue->Assign(GetJSValueFromMap(resolveRs.nodes[0]));
     return true;
   }
   if (resolveRs.dwFlags == XFA_RESOVENODE_RSTYPE_Attribute) {
     const XFA_SCRIPTATTRIBUTEINFO* lpAttributeInfo = resolveRs.pScriptAttribute;
     if (lpAttributeInfo) {
       (resolveRs.nodes[0]->*(lpAttributeInfo->lpfnCallback))(
           pValue, bSetting, (XFA_ATTRIBUTE)lpAttributeInfo->eAttribute);
     }
   }
   return true;
@@ skipping 10 matching lines @@
     if (szPropName == kFormCalcRuntime) {
       lpScriptContext->m_hFM2JSContext->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) {
-        FXJSE_Value_Set(pValue, lpScriptContext->GetJSValueFromMap(pObj));
+        pValue->Assign(lpScriptContext->GetJSValueFromMap(pObj));
         return;
       }
     }
   }
   uint32_t dwFlag = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Properties |
                     XFA_RESOLVENODE_Attributes;
   CXFA_Node* pRefNode = ToNode(lpScriptContext->GetThisObject());
   if (pOriginalObject->GetObjectType() == XFA_OBJECTTYPE_VariablesThis) {
     pRefNode = ToNode(lpCurNode);
   }
@@ skipping 18 matching lines @@
     return;
   }
   pNotify->GetDocProvider()->GetGlobalProperty(pNotify->GetHDOC(), szPropName,
                                                pValue);
 }
 void CXFA_ScriptContext::NormalPropertyGetter(CFXJSE_Value* pOriginalValue,
                                               const CFX_ByteStringC& szPropName,
                                               CFXJSE_Value* pReturnValue) {
   CXFA_Object* pOriginalObject = ToObject(pOriginalValue, nullptr);
   if (!pOriginalObject) {
-    FXJSE_Value_SetUndefined(pReturnValue);
+    pReturnValue->SetUndefined();
     return;
   }
   CFX_WideString wsPropName = CFX_WideString::FromUTF8(szPropName);
   CXFA_ScriptContext* lpScriptContext =
       pOriginalObject->GetDocument()->GetScriptContext();
   CXFA_Object* pObject = lpScriptContext->GetVariablesThis(pOriginalObject);
   if (wsPropName == FX_WSTRC(L"xfa")) {
     CFXJSE_Value* pValue = lpScriptContext->GetJSValueFromMap(
         lpScriptContext->GetDocument()->GetRoot());
-    FXJSE_Value_Set(pReturnValue, pValue);
+    pReturnValue->Assign(pValue);
     return;
   }
   uint32_t dwFlag = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Properties |
                     XFA_RESOLVENODE_Attributes;
   FX_BOOL bRet = lpScriptContext->QueryNodeByFlag(
       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(), pReturnValue, dwFlag, FALSE);
   }
   if (bRet) {
     return;
   }
   CXFA_Object* pScriptObject =
       lpScriptContext->GetVariablesThis(pOriginalObject, TRUE);
   if (pScriptObject) {
     bRet = lpScriptContext->QueryVariableValue(ToNode(pScriptObject),
                                                szPropName, pReturnValue, TRUE);
   }
   if (!bRet) {
-    FXJSE_Value_SetUndefined(pReturnValue);
+    pReturnValue->SetUndefined();
   }
 }
 void CXFA_ScriptContext::NormalPropertySetter(CFXJSE_Value* pOriginalValue,
                                               const CFX_ByteStringC& szPropName,
                                               CFXJSE_Value* pReturnValue) {
   CXFA_Object* pOriginalObject = ToObject(pOriginalValue, nullptr);
   if (!pOriginalObject)
     return;
 
   CXFA_ScriptContext* lpScriptContext =
@@ skipping 183 matching lines @@
   void* lpVariables = m_mapVariableToContext.GetValueAt(pScriptNode);
   if (!lpVariables)
     return FALSE;
 
   FX_BOOL bRes = FALSE;
   CFXJSE_Context* pVariableContext = static_cast<CFXJSE_Context*>(lpVariables);
   std::unique_ptr<CFXJSE_Value> pObject(
       FXJSE_Context_GetGlobalObject(pVariableContext));
   std::unique_ptr<CFXJSE_Value> hVariableValue(new CFXJSE_Value(m_pIsolate));
   if (!bGetter) {
-    FXJSE_Value_SetObjectOwnProp(pObject.get(), szPropName, pValue);
+    pObject->SetObjectOwnProperty(szPropName, pValue);
     bRes = TRUE;
-  } else if (FXJSE_Value_ObjectHasOwnProp(pObject.get(), szPropName, FALSE)) {
-    FXJSE_Value_GetObjectProp(pObject.get(), szPropName, hVariableValue.get());
+  } else if (pObject->HasObjectOwnProperty(szPropName, FALSE)) {
+    pObject->GetObjectProperty(szPropName, hVariableValue.get());
     if (FXJSE_Value_IsFunction(hVariableValue.get()))
-      FXJSE_Value_SetFunctionBind(pValue, hVariableValue.get(), pObject.get());
+      pValue->SetFunctionBind(hVariableValue.get(), pObject.get());
     else if (bGetter)
-      FXJSE_Value_Set(pValue, hVariableValue.get());
+      pValue->Assign(hVariableValue.get());
     else
-      FXJSE_Value_Set(hVariableValue.get(), pValue);
+      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);
     std::unique_ptr<CFXJSE_Value> pObject(
         FXJSE_Context_GetGlobalObject(pVariableContext));
     delete ToThisProxy(pObject.get(), nullptr);
     FXJSE_Context_Release(pVariableContext);
   }
   m_mapVariableToContext.RemoveAll();
 }
 
 void CXFA_ScriptContext::DefineJsClass() {
   m_pJsClass = FXJSE_DefineClass(m_pJsContext, &NormalClassDescriptor);
 }
 
 void CXFA_ScriptContext::RemoveBuiltInObjs(CFXJSE_Context* pContext) const {
   static const CFX_ByteStringC OBJ_NAME[2] = {"Number", "Date"};
   std::unique_ptr<CFXJSE_Value> pObject(
       FXJSE_Context_GetGlobalObject(pContext));
   std::unique_ptr<CFXJSE_Value> hProp(new CFXJSE_Value(m_pIsolate));
   for (int i = 0; i < 2; ++i) {
-    if (FXJSE_Value_GetObjectProp(pObject.get(), OBJ_NAME[i], hProp.get()))
-      FXJSE_Value_DeleteObjectProp(pObject.get(), OBJ_NAME[i]);
+    if (pObject->GetObjectProperty(OBJ_NAME[i], hProp.get()))
+      pObject.get()->DeleteObjectProperty(OBJ_NAME[i]);
   }
 }
 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) {
@@ skipping 156 matching lines @@
 }
 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);
-    FXJSE_Value_SetObject(jsValue, pObject, m_pJsClass);
+    jsValue->SetObject(pObject, m_pJsClass);
     m_mapXFAToValue.SetAt(pObject, jsValue);
     pValue = jsValue;
   }
   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);
@@ skipping 22 matching lines @@
   }
 }
 void CXFA_ScriptContext::AddNodesOfRunScript(CXFA_Node* pNode) {
   if (!m_pScriptNodeArray) {
     return;
   }
   if (m_pScriptNodeArray->Find(pNode) == -1) {
     m_pScriptNodeArray->Add(pNode);
   }
 }