Remove various FXJSE Value methods.

xfa/fxfa/fm2js/xfa_fm2jscontext.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_fm2jscontext.h"
 
 #include <time.h>
 
@@ skipping 499 matching lines @@
                             const CFX_ByteStringC& szFuncName,
                             CFXJSE_Arguments& args) {
   if (args.GetLength() != 1) {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Abs");
     return;
   }
 
   std::unique_ptr<CFXJSE_Value> argOne = args.GetValue(0);
   if (ValueIsNull(pThis, argOne.get())) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
 
   FX_DOUBLE dValue = ValueToDouble(pThis, argOne.get());
   if (dValue < 0)
     dValue = -dValue;
 
-  FXJSE_Value_SetDouble(args.GetReturnValue(), dValue);
+  args.GetReturnValue()->SetDouble(dValue);
 }
 
 // static
 void CXFA_FM2JSContext::Avg(CFXJSE_Value* pThis,
                             const CFX_ByteStringC& szFuncName,
                             CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if (argc < 1) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
 
   v8::Isolate* pIsolate = ToJSContext(pThis, nullptr)->GetScriptRuntime();
   uint32_t uCount = 0;
   FX_DOUBLE dSum = 0.0;
   for (int32_t i = 0; i < argc; i++) {
     std::unique_ptr<CFXJSE_Value> argValue = args.GetValue(i);
     if (FXJSE_Value_IsNull(argValue.get()))
       continue;
 
     if (!FXJSE_Value_IsArray(argValue.get())) {
       dSum += ValueToDouble(pThis, argValue.get());
       uCount++;
       continue;
     }
 
     std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
-    FXJSE_Value_GetObjectProp(argValue.get(), "length", lengthValue.get());
-    int32_t iLength = FXJSE_Value_ToInteger(lengthValue.get());
+    argValue->GetObjectProperty("length", lengthValue.get());
+    int32_t iLength = lengthValue->ToInteger();
 
     if (iLength > 2) {
       std::unique_ptr<CFXJSE_Value> propertyValue(new CFXJSE_Value(pIsolate));
-      FXJSE_Value_GetObjectPropByIdx(argValue.get(), 1, propertyValue.get());
+      argValue->GetObjectPropertyByIdx(1, propertyValue.get());
 
       std::unique_ptr<CFXJSE_Value> jsObjectValue(new CFXJSE_Value(pIsolate));
       if (FXJSE_Value_IsNull(propertyValue.get())) {
         for (int32_t j = 2; j < iLength; j++) {
-          FXJSE_Value_GetObjectPropByIdx(argValue.get(), j,
-                                         jsObjectValue.get());
+          argValue->GetObjectPropertyByIdx(j, jsObjectValue.get());
           std::unique_ptr<CFXJSE_Value> defaultPropValue(
               new CFXJSE_Value(pIsolate));
           GetObjectDefaultValue(jsObjectValue.get(), defaultPropValue.get());
           if (FXJSE_Value_IsNull(defaultPropValue.get()))
             continue;
 
           dSum += ValueToDouble(pThis, defaultPropValue.get());
           uCount++;
         }
       } else {
         CFX_ByteString propertyStr;
-        FXJSE_Value_ToUTF8String(propertyValue.get(), propertyStr);
+        propertyValue->ToString(propertyStr);
         for (int32_t j = 2; j < iLength; j++) {
-          FXJSE_Value_GetObjectPropByIdx(argValue.get(), j,
-                                         jsObjectValue.get());
+          argValue->GetObjectPropertyByIdx(j, jsObjectValue.get());
           std::unique_ptr<CFXJSE_Value> newPropertyValue(
               new CFXJSE_Value(pIsolate));
-          FXJSE_Value_GetObjectProp(jsObjectValue.get(),
-                                    propertyStr.AsStringC(),
-                                    newPropertyValue.get());
+          jsObjectValue->GetObjectProperty(propertyStr.AsStringC(),
+                                           newPropertyValue.get());
           if (FXJSE_Value_IsNull(newPropertyValue.get()))
             continue;
 
           dSum += ValueToDouble(pThis, newPropertyValue.get());
           uCount++;
         }
       }
     }
   }
   if (uCount == 0) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
 
-  FXJSE_Value_SetDouble(args.GetReturnValue(), dSum / uCount);
+  args.GetReturnValue()->SetDouble(dSum / uCount);
 }
 
 // static
 void CXFA_FM2JSContext::Ceil(CFXJSE_Value* pThis,
                              const CFX_ByteStringC& szFuncName,
                              CFXJSE_Arguments& args) {
   if (args.GetLength() != 1) {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Ceil");
     return;
   }
 
   std::unique_ptr<CFXJSE_Value> argValue = GetSimpleValue(pThis, args, 0);
   if (ValueIsNull(pThis, argValue.get())) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
 
-  FXJSE_Value_SetFloat(args.GetReturnValue(),
-                       FXSYS_ceil(ValueToFloat(pThis, argValue.get())));
+  args.GetReturnValue()->SetFloat(
+      FXSYS_ceil(ValueToFloat(pThis, argValue.get())));
 }
 
 // static
 void CXFA_FM2JSContext::Count(CFXJSE_Value* pThis,
                               const CFX_ByteStringC& szFuncName,
                               CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = ToJSContext(pThis, nullptr);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   int32_t iCount = 0;
   for (int32_t i = 0; i < args.GetLength(); i++) {
     std::unique_ptr<CFXJSE_Value> argValue = args.GetValue(i);
     if (FXJSE_Value_IsNull(argValue.get()))
       continue;
 
     if (FXJSE_Value_IsArray(argValue.get())) {
       std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
-      FXJSE_Value_GetObjectProp(argValue.get(), "length", lengthValue.get());
+      argValue->GetObjectProperty("length", lengthValue.get());
 
-      int32_t iLength = FXJSE_Value_ToInteger(lengthValue.get());
+      int32_t iLength = lengthValue->ToInteger();
       if (iLength <= 2) {
         pContext->ThrowException(XFA_IDS_ARGUMENT_MISMATCH);
         return;
       }
 
       std::unique_ptr<CFXJSE_Value> propertyValue(new CFXJSE_Value(pIsolate));
       std::unique_ptr<CFXJSE_Value> jsObjectValue(new CFXJSE_Value(pIsolate));
       std::unique_ptr<CFXJSE_Value> newPropertyValue(
           new CFXJSE_Value(pIsolate));
-      FXJSE_Value_GetObjectPropByIdx(argValue.get(), 1, propertyValue.get());
-      FXJSE_Value_GetObjectPropByIdx(argValue.get(), 2, jsObjectValue.get());
+      argValue->GetObjectPropertyByIdx(1, propertyValue.get());
+      argValue->GetObjectPropertyByIdx(2, jsObjectValue.get());
       if (FXJSE_Value_IsNull(propertyValue.get())) {
         for (int32_t j = 2; j < iLength; j++) {
-          FXJSE_Value_GetObjectPropByIdx(argValue.get(), j,
-                                         jsObjectValue.get());
+          argValue->GetObjectPropertyByIdx(j, jsObjectValue.get());
           GetObjectDefaultValue(jsObjectValue.get(), newPropertyValue.get());
           if (!FXJSE_Value_IsNull(newPropertyValue.get()))
             iCount++;
         }
       } else {
         CFX_ByteString propertyStr;
-        FXJSE_Value_ToUTF8String(propertyValue.get(), propertyStr);
+        propertyValue->ToString(propertyStr);
         for (int32_t j = 2; j < iLength; j++) {
-          FXJSE_Value_GetObjectPropByIdx(argValue.get(), j,
-                                         jsObjectValue.get());
-          FXJSE_Value_GetObjectProp(jsObjectValue.get(),
-                                    propertyStr.AsStringC(),
-                                    newPropertyValue.get());
+          argValue->GetObjectPropertyByIdx(j, jsObjectValue.get());
+          jsObjectValue->GetObjectProperty(propertyStr.AsStringC(),
+                                           newPropertyValue.get());
           iCount += (FXJSE_Value_IsNull(newPropertyValue.get()) ? 0 : 1);
         }
       }
     } else if (FXJSE_Value_IsObject(argValue.get())) {
       std::unique_ptr<CFXJSE_Value> newPropertyValue(
           new CFXJSE_Value(pIsolate));
       GetObjectDefaultValue(argValue.get(), newPropertyValue.get());
       if (!FXJSE_Value_IsNull(newPropertyValue.get()))
         iCount++;
     } else {
       iCount++;
     }
   }
-  FXJSE_Value_SetInteger(args.GetReturnValue(), iCount);
+  args.GetReturnValue()->SetInteger(iCount);
 }
 
 // static
 void CXFA_FM2JSContext::Floor(CFXJSE_Value* pThis,
                               const CFX_ByteStringC& szFuncName,
                               CFXJSE_Arguments& args) {
   if (args.GetLength() != 1) {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Floor");
     return;
   }
 
   std::unique_ptr<CFXJSE_Value> argValue = GetSimpleValue(pThis, args, 0);
   if (ValueIsNull(pThis, argValue.get())) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
 
-  FXJSE_Value_SetFloat(args.GetReturnValue(),
-                       FXSYS_floor(ValueToFloat(pThis, argValue.get())));
+  args.GetReturnValue()->SetFloat(
+      FXSYS_floor(ValueToFloat(pThis, argValue.get())));
 }
 
 // static
 void CXFA_FM2JSContext::Max(CFXJSE_Value* pThis,
                             const CFX_ByteStringC& szFuncName,
                             CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = ToJSContext(pThis, nullptr);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   uint32_t uCount = 0;
   FX_DOUBLE dMaxValue = 0.0;
   for (int32_t i = 0; i < args.GetLength(); i++) {
     std::unique_ptr<CFXJSE_Value> argValue = args.GetValue(i);
     if (FXJSE_Value_IsNull(argValue.get()))
       continue;
 
     if (FXJSE_Value_IsArray(argValue.get())) {
       std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
-      FXJSE_Value_GetObjectProp(argValue.get(), "length", lengthValue.get());
-      int32_t iLength = FXJSE_Value_ToInteger(lengthValue.get());
+      argValue->GetObjectProperty("length", lengthValue.get());
+      int32_t iLength = lengthValue->ToInteger();
       if (iLength <= 2) {
         pContext->ThrowException(XFA_IDS_ARGUMENT_MISMATCH);
         return;
       }
 
       std::unique_ptr<CFXJSE_Value> propertyValue(new CFXJSE_Value(pIsolate));
       std::unique_ptr<CFXJSE_Value> jsObjectValue(new CFXJSE_Value(pIsolate));
       std::unique_ptr<CFXJSE_Value> newPropertyValue(
           new CFXJSE_Value(pIsolate));
-      FXJSE_Value_GetObjectPropByIdx(argValue.get(), 1, propertyValue.get());
-      FXJSE_Value_GetObjectPropByIdx(argValue.get(), 2, jsObjectValue.get());
+      argValue->GetObjectPropertyByIdx(1, propertyValue.get());
+      argValue->GetObjectPropertyByIdx(2, jsObjectValue.get());
       if (FXJSE_Value_IsNull(propertyValue.get())) {
         for (int32_t j = 2; j < iLength; j++) {
-          FXJSE_Value_GetObjectPropByIdx(argValue.get(), j,
-                                         jsObjectValue.get());
+          argValue->GetObjectPropertyByIdx(j, jsObjectValue.get());
           GetObjectDefaultValue(jsObjectValue.get(), newPropertyValue.get());
           if (FXJSE_Value_IsNull(newPropertyValue.get()))
             continue;
 
           uCount++;
           FX_DOUBLE dValue = ValueToDouble(pThis, newPropertyValue.get());
           dMaxValue = (uCount == 1) ? dValue : std::max(dMaxValue, dValue);
         }
       } else {
         CFX_ByteString propertyStr;
-        FXJSE_Value_ToUTF8String(propertyValue.get(), propertyStr);
+        propertyValue->ToString(propertyStr);
         for (int32_t j = 2; j < iLength; j++) {
-          FXJSE_Value_GetObjectPropByIdx(argValue.get(), j,
-                                         jsObjectValue.get());
-          FXJSE_Value_GetObjectProp(jsObjectValue.get(),
-                                    propertyStr.AsStringC(),
-                                    newPropertyValue.get());
+          argValue->GetObjectPropertyByIdx(j, jsObjectValue.get());
+          jsObjectValue->GetObjectProperty(propertyStr.AsStringC(),
+                                           newPropertyValue.get());
           if (FXJSE_Value_IsNull(newPropertyValue.get()))
             continue;
 
           uCount++;
           FX_DOUBLE dValue = ValueToDouble(pThis, newPropertyValue.get());
           dMaxValue = (uCount == 1) ? dValue : std::max(dMaxValue, dValue);
         }
       }
     } else if (FXJSE_Value_IsObject(argValue.get())) {
       std::unique_ptr<CFXJSE_Value> newPropertyValue(
           new CFXJSE_Value(pIsolate));
       GetObjectDefaultValue(argValue.get(), newPropertyValue.get());
       if (FXJSE_Value_IsNull(newPropertyValue.get()))
         continue;
 
       uCount++;
       FX_DOUBLE dValue = ValueToDouble(pThis, newPropertyValue.get());
       dMaxValue = (uCount == 1) ? dValue : std::max(dMaxValue, dValue);
     } else {
       uCount++;
       FX_DOUBLE dValue = ValueToDouble(pThis, argValue.get());
       dMaxValue = (uCount == 1) ? dValue : std::max(dMaxValue, dValue);
     }
   }
   if (uCount == 0) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
 
-  FXJSE_Value_SetDouble(args.GetReturnValue(), dMaxValue);
+  args.GetReturnValue()->SetDouble(dMaxValue);
 }
 
 // static
 void CXFA_FM2JSContext::Min(CFXJSE_Value* pThis,
                             const CFX_ByteStringC& szFuncName,
                             CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = ToJSContext(pThis, nullptr);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   uint32_t uCount = 0;
   FX_DOUBLE dMinValue = 0.0;
   for (int32_t i = 0; i < args.GetLength(); i++) {
     std::unique_ptr<CFXJSE_Value> argValue = args.GetValue(i);
     if (FXJSE_Value_IsNull(argValue.get()))
       continue;
 
     if (FXJSE_Value_IsArray(argValue.get())) {
       std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
-      FXJSE_Value_GetObjectProp(argValue.get(), "length", lengthValue.get());
-      int32_t iLength = FXJSE_Value_ToInteger(lengthValue.get());
+      argValue->GetObjectProperty("length", lengthValue.get());
+      int32_t iLength = lengthValue->ToInteger();
       if (iLength <= 2) {
         pContext->ThrowException(XFA_IDS_ARGUMENT_MISMATCH);
         return;
       }
 
       std::unique_ptr<CFXJSE_Value> propertyValue(new CFXJSE_Value(pIsolate));
       std::unique_ptr<CFXJSE_Value> jsObjectValue(new CFXJSE_Value(pIsolate));
       std::unique_ptr<CFXJSE_Value> newPropertyValue(
           new CFXJSE_Value(pIsolate));
-      FXJSE_Value_GetObjectPropByIdx(argValue.get(), 1, propertyValue.get());
-      FXJSE_Value_GetObjectPropByIdx(argValue.get(), 2, jsObjectValue.get());
+      argValue->GetObjectPropertyByIdx(1, propertyValue.get());
+      argValue->GetObjectPropertyByIdx(2, jsObjectValue.get());
       if (FXJSE_Value_IsNull(propertyValue.get())) {
         for (int32_t j = 2; j < iLength; j++) {
-          FXJSE_Value_GetObjectPropByIdx(argValue.get(), j,
-                                         jsObjectValue.get());
+          argValue->GetObjectPropertyByIdx(j, jsObjectValue.get());
           GetObjectDefaultValue(jsObjectValue.get(), newPropertyValue.get());
           if (FXJSE_Value_IsNull(newPropertyValue.get()))
             continue;
 
           uCount++;
           FX_DOUBLE dValue = ValueToDouble(pThis, newPropertyValue.get());
           dMinValue = uCount == 1 ? dValue : std::min(dMinValue, dValue);
         }
       } else {
         CFX_ByteString propertyStr;
-        FXJSE_Value_ToUTF8String(propertyValue.get(), propertyStr);
+        propertyValue->ToString(propertyStr);
         for (int32_t j = 2; j < iLength; j++) {
-          FXJSE_Value_GetObjectPropByIdx(argValue.get(), j,
-                                         jsObjectValue.get());
-          FXJSE_Value_GetObjectProp(jsObjectValue.get(),
-                                    propertyStr.AsStringC(),
-                                    newPropertyValue.get());
+          argValue->GetObjectPropertyByIdx(j, jsObjectValue.get());
+          jsObjectValue->GetObjectProperty(propertyStr.AsStringC(),
+                                           newPropertyValue.get());
           if (FXJSE_Value_IsNull(newPropertyValue.get()))
             continue;
 
           uCount++;
           FX_DOUBLE dValue = ValueToDouble(pThis, newPropertyValue.get());
           dMinValue = uCount == 1 ? dValue : std::min(dMinValue, dValue);
         }
       }
     } else if (FXJSE_Value_IsObject(argValue.get())) {
       std::unique_ptr<CFXJSE_Value> newPropertyValue(
           new CFXJSE_Value(pIsolate));
       GetObjectDefaultValue(argValue.get(), newPropertyValue.get());
       if (FXJSE_Value_IsNull(newPropertyValue.get()))
         continue;
 
       uCount++;
       FX_DOUBLE dValue = ValueToDouble(pThis, newPropertyValue.get());
       dMinValue = uCount == 1 ? dValue : std::min(dMinValue, dValue);
     } else {
       uCount++;
       FX_DOUBLE dValue = ValueToDouble(pThis, argValue.get());
       dMinValue = uCount == 1 ? dValue : std::min(dMinValue, dValue);
     }
   }
   if (uCount == 0) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
 
-  FXJSE_Value_SetDouble(args.GetReturnValue(), dMinValue);
+  args.GetReturnValue()->SetDouble(dMinValue);
 }
 
 // static
 void CXFA_FM2JSContext::Mod(CFXJSE_Value* pThis,
                             const CFX_ByteStringC& szFuncName,
                             CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = ToJSContext(pThis, nullptr);
   if (args.GetLength() != 2) {
     pContext->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Mod");
     return;
   }
 
   std::unique_ptr<CFXJSE_Value> argOne = args.GetValue(0);
   std::unique_ptr<CFXJSE_Value> argTwo = args.GetValue(1);
   if (FXJSE_Value_IsNull(argOne.get()) || FXJSE_Value_IsNull(argTwo.get())) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
 
   bool argOneResult;
   FX_DOUBLE dDividend = ExtractDouble(pThis, argOne.get(), &argOneResult);
   bool argTwoResult;
   FX_DOUBLE dDivisor = ExtractDouble(pThis, argTwo.get(), &argTwoResult);
   if (!argOneResult || !argTwoResult) {
     pContext->ThrowException(XFA_IDS_ARGUMENT_MISMATCH);
     return;
   }
 
   if (dDivisor == 0.0) {
     pContext->ThrowException(XFA_IDS_DIVIDE_ZERO);
     return;
   }
 
-  FXJSE_Value_SetDouble(args.GetReturnValue(),
-                        dDividend - dDivisor * (int32_t)(dDividend / dDivisor));
+  args.GetReturnValue()->SetDouble(dDividend -
+                                   dDivisor * (int32_t)(dDividend / dDivisor));
 }
 
 // static
 void CXFA_FM2JSContext::Round(CFXJSE_Value* pThis,
                               const CFX_ByteStringC& szFuncName,
                               CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = ToJSContext(pThis, nullptr);
   int32_t argc = args.GetLength();
   if (argc < 1 || argc > 2) {
     pContext->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Round");
     return;
   }
 
   std::unique_ptr<CFXJSE_Value> argOne = args.GetValue(0);
   if (FXJSE_Value_IsNull(argOne.get())) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
 
   bool dValueRet;
   FX_DOUBLE dValue = ExtractDouble(pThis, argOne.get(), &dValueRet);
   if (!dValueRet) {
     pContext->ThrowException(XFA_IDS_ARGUMENT_MISMATCH);
     return;
   }
 
   uint8_t uPrecision = 0;
   if (argc > 1) {
     std::unique_ptr<CFXJSE_Value> argTwo = args.GetValue(1);
     if (FXJSE_Value_IsNull(argTwo.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
       return;
     }
 
     bool dPrecisionRet;
     FX_DOUBLE dPrecision = ExtractDouble(pThis, argTwo.get(), &dPrecisionRet);
     if (!dPrecisionRet) {
       pContext->ThrowException(XFA_IDS_ARGUMENT_MISMATCH);
       return;
     }
 
     uPrecision =
         static_cast<uint8_t>(std::min(std::max(dPrecision, 0.0), 12.0));
   }
 
   CFX_Decimal decimalValue((FX_FLOAT)dValue, uPrecision);
   CFX_WideString wsValue = decimalValue;
-  FXJSE_Value_SetUTF8String(args.GetReturnValue(),
-                            wsValue.UTF8Encode().AsStringC());
+  args.GetReturnValue()->SetString(wsValue.UTF8Encode().AsStringC());
 }
 
 // static
 void CXFA_FM2JSContext::Sum(CFXJSE_Value* pThis,
                             const CFX_ByteStringC& szFuncName,
                             CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if (argc == 0) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
 
   CXFA_FM2JSContext* pContext = ToJSContext(pThis, nullptr);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   uint32_t uCount = 0;
   FX_DOUBLE dSum = 0.0;
   for (int32_t i = 0; i < argc; i++) {
     std::unique_ptr<CFXJSE_Value> argValue = args.GetValue(i);
     if (FXJSE_Value_IsNull(argValue.get()))
       continue;
 
     if (FXJSE_Value_IsArray(argValue.get())) {
       std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
-      FXJSE_Value_GetObjectProp(argValue.get(), "length", lengthValue.get());
-      int32_t iLength = FXJSE_Value_ToInteger(lengthValue.get());
+      argValue->GetObjectProperty("length", lengthValue.get());
+      int32_t iLength = lengthValue->ToInteger();
       if (iLength <= 2) {
         pContext->ThrowException(XFA_IDS_ARGUMENT_MISMATCH);
         return;
       }
 
       std::unique_ptr<CFXJSE_Value> propertyValue(new CFXJSE_Value(pIsolate));
-      FXJSE_Value_GetObjectPropByIdx(argValue.get(), 1, propertyValue.get());
+      argValue->GetObjectPropertyByIdx(1, propertyValue.get());
       std::unique_ptr<CFXJSE_Value> jsObjectValue(new CFXJSE_Value(pIsolate));
       std::unique_ptr<CFXJSE_Value> newPropertyValue(
           new CFXJSE_Value(pIsolate));
       if (FXJSE_Value_IsNull(propertyValue.get())) {
         for (int32_t j = 2; j < iLength; j++) {
-          FXJSE_Value_GetObjectPropByIdx(argValue.get(), j,
-                                         jsObjectValue.get());
+          argValue->GetObjectPropertyByIdx(j, jsObjectValue.get());
           GetObjectDefaultValue(jsObjectValue.get(), newPropertyValue.get());
           if (FXJSE_Value_IsNull(newPropertyValue.get()))
             continue;
 
           dSum += ValueToDouble(pThis, jsObjectValue.get());
           uCount++;
         }
       } else {
         CFX_ByteString propertyStr;
-        FXJSE_Value_ToUTF8String(propertyValue.get(), propertyStr);
+        propertyValue->ToString(propertyStr);
         for (int32_t j = 2; j < iLength; j++) {
-          FXJSE_Value_GetObjectPropByIdx(argValue.get(), j,
-                                         jsObjectValue.get());
-          FXJSE_Value_GetObjectProp(jsObjectValue.get(),
-                                    propertyStr.AsStringC(),
-                                    newPropertyValue.get());
+          argValue->GetObjectPropertyByIdx(j, jsObjectValue.get());
+          jsObjectValue->GetObjectProperty(propertyStr.AsStringC(),
+                                           newPropertyValue.get());
           if (FXJSE_Value_IsNull(newPropertyValue.get()))
             continue;
 
           dSum += ValueToDouble(pThis, newPropertyValue.get());
           uCount++;
         }
       }
     } else if (FXJSE_Value_IsObject(argValue.get())) {
       std::unique_ptr<CFXJSE_Value> newPropertyValue(
           new CFXJSE_Value(pIsolate));
       GetObjectDefaultValue(argValue.get(), newPropertyValue.get());
       if (FXJSE_Value_IsNull(newPropertyValue.get()))
         continue;
 
       dSum += ValueToDouble(pThis, argValue.get());
       uCount++;
     } else {
       dSum += ValueToDouble(pThis, argValue.get());
       uCount++;
     }
   }
   if (uCount == 0) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
 
-  FXJSE_Value_SetDouble(args.GetReturnValue(), dSum);
+  args.GetReturnValue()->SetDouble(dSum);
 }
 
 // static
 void CXFA_FM2JSContext::Date(CFXJSE_Value* pThis,
                              const CFX_ByteStringC& szFuncName,
                              CFXJSE_Arguments& args) {
   if (args.GetLength() != 0) {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Date");
     return;
   }
 
   time_t currentTime;
   time(&currentTime);
   struct tm* pTmStruct = gmtime(&currentTime);
 
   CFX_ByteString bufferYear;
   CFX_ByteString bufferMon;
   CFX_ByteString bufferDay;
   bufferYear.Format("%d", pTmStruct->tm_year + 1900);
   bufferMon.Format("%02d", pTmStruct->tm_mon + 1);
   bufferDay.Format("%02d", pTmStruct->tm_mday);
 
   CFX_ByteString bufferCurrent = bufferYear + bufferMon + bufferDay;
-  FXJSE_Value_SetInteger(args.GetReturnValue(),
-                         DateString2Num(bufferCurrent.AsStringC()));
+  args.GetReturnValue()->SetInteger(DateString2Num(bufferCurrent.AsStringC()));
 }
 
 // static
 void CXFA_FM2JSContext::Date2Num(CFXJSE_Value* pThis,
                                  const CFX_ByteStringC& szFuncName,
                                  CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if (argc < 1 || argc > 3) {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Date2Num");
     return;
   }
 
   std::unique_ptr<CFXJSE_Value> dateValue = GetSimpleValue(pThis, args, 0);
   if (ValueIsNull(pThis, dateValue.get())) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
 
   CFX_ByteString dateString;
   ValueToUTF8String(dateValue.get(), dateString);
 
   CFX_ByteString formatString;
   if (argc > 1) {
     std::unique_ptr<CFXJSE_Value> formatValue = GetSimpleValue(pThis, args, 1);
     if (ValueIsNull(pThis, formatValue.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
       return;
     }
     ValueToUTF8String(formatValue.get(), formatString);
   }
 
   CFX_ByteString localString;
   if (argc > 2) {
     std::unique_ptr<CFXJSE_Value> localValue = GetSimpleValue(pThis, args, 2);
     if (ValueIsNull(pThis, localValue.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
       return;
     }
     ValueToUTF8String(localValue.get(), localString);
   }
 
   CFX_ByteString szIsoDateString;
   if (!Local2IsoDate(pThis, dateString.AsStringC(), formatString.AsStringC(),
                      localString.AsStringC(), szIsoDateString)) {
-    FXJSE_Value_SetInteger(args.GetReturnValue(), 0);
+    args.GetReturnValue()->SetInteger(0);
     return;
   }
 
-  FXJSE_Value_SetInteger(args.GetReturnValue(),
-                         DateString2Num(szIsoDateString.AsStringC()));
+  args.GetReturnValue()->SetInteger(
+      DateString2Num(szIsoDateString.AsStringC()));
 }
 
 // static
 void CXFA_FM2JSContext::DateFmt(CFXJSE_Value* pThis,
                                 const CFX_ByteStringC& szFuncName,
                                 CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if (argc > 2) {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Date2Num");
     return;
   }
 
   int32_t iStyle = 0;
   if (argc > 0) {
     std::unique_ptr<CFXJSE_Value> argStyle = GetSimpleValue(pThis, args, 0);
     if (FXJSE_Value_IsNull(argStyle.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
       return;
     }
 
     iStyle = (int32_t)ValueToFloat(pThis, argStyle.get());
     if (iStyle < 0 || iStyle > 4)
       iStyle = 0;
   }
 
   CFX_ByteString szLocal;
   if (argc > 1) {
     std::unique_ptr<CFXJSE_Value> argLocal = GetSimpleValue(pThis, args, 1);
     if (FXJSE_Value_IsNull(argLocal.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
       return;
     }
     ValueToUTF8String(argLocal.get(), szLocal);
   }
 
   CFX_ByteString formatStr;
   GetStandardDateFormat(pThis, iStyle, szLocal.AsStringC(), formatStr);
-  FXJSE_Value_SetUTF8String(args.GetReturnValue(), formatStr.AsStringC());
+  args.GetReturnValue()->SetString(formatStr.AsStringC());
 }
 
 // static
 void CXFA_FM2JSContext::IsoDate2Num(CFXJSE_Value* pThis,
                                     const CFX_ByteStringC& szFuncName,
                                     CFXJSE_Arguments& args) {
   if (args.GetLength() != 1) {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"IsoDate2Num");
     return;
   }
 
   std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
   if (FXJSE_Value_IsNull(argOne.get())) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
 
   CFX_ByteString szArgString;
   ValueToUTF8String(argOne.get(), szArgString);
-  FXJSE_Value_SetInteger(args.GetReturnValue(),
-                         DateString2Num(szArgString.AsStringC()));
+  args.GetReturnValue()->SetInteger(DateString2Num(szArgString.AsStringC()));
 }
 
 // static
 void CXFA_FM2JSContext::IsoTime2Num(CFXJSE_Value* pThis,
                                     const CFX_ByteStringC& szFuncName,
                                     CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = ToJSContext(pThis, nullptr);
   if (args.GetLength() != 1) {
     pContext->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                              L"IsoTime2Num");
     return;
   }
 
   std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
   if (ValueIsNull(pThis, argOne.get())) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
 
   CXFA_Document* pDoc = pContext->GetDocument();
   CXFA_LocaleMgr* pMgr = pDoc->GetLocalMgr();
 
   CFX_ByteString szArgString;
   ValueToUTF8String(argOne.get(), szArgString);
   szArgString = szArgString.Mid(szArgString.Find('T', 0) + 1);
   if (szArgString.IsEmpty()) {
-    FXJSE_Value_SetInteger(args.GetReturnValue(), 0);
+    args.GetReturnValue()->SetInteger(0);
     return;
   }
 
   CXFA_LocaleValue timeValue(
       XFA_VT_TIME, CFX_WideString::FromUTF8(szArgString.AsStringC()), pMgr);
   if (!timeValue.IsValid()) {
-    FXJSE_Value_SetInteger(args.GetReturnValue(), 0);
+    args.GetReturnValue()->SetInteger(0);
     return;
   }
 
   CFX_Unitime uniTime = timeValue.GetTime();
   int32_t hour = uniTime.GetHour();
   int32_t min = uniTime.GetMinute();
   int32_t second = uniTime.GetSecond();
   int32_t milSecond = uniTime.GetMillisecond();
 
   FX_TIMEZONE tzLocale;
   pMgr->GetDefLocale()->GetTimeZone(tzLocale);
 
   // TODO(dsinclair): See if there is other time conversion code in pdfium and
   //   consolidate.
   int32_t mins = hour * 60 + min;
   mins -= (tzLocale.tzHour * 60);
   while (mins > 1440)
     mins -= 1440;
   while (mins < 0)
     mins += 1440;
   hour = mins / 60;
   min = mins % 60;
-  int32_t iResult =
-      hour * 3600000 + min * 60000 + second * 1000 + milSecond + 1;
-  FXJSE_Value_SetInteger(args.GetReturnValue(), iResult);
+
+  args.GetReturnValue()->SetInteger(hour * 3600000 + min * 60000 +
+                                    second * 1000 + milSecond + 1);
 }
 
 // static
 void CXFA_FM2JSContext::LocalDateFmt(CFXJSE_Value* pThis,
                                      const CFX_ByteStringC& szFuncName,
                                      CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if (argc > 2) {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"LocalDateFmt");
     return;
   }
 
   int32_t iStyle = 0;
   if (argc > 0) {
     std::unique_ptr<CFXJSE_Value> argStyle = GetSimpleValue(pThis, args, 0);
     if (FXJSE_Value_IsNull(argStyle.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
       return;
     }
     iStyle = (int32_t)ValueToFloat(pThis, argStyle.get());
     if (iStyle > 4 || iStyle < 0)
       iStyle = 0;
   }
 
   CFX_ByteString szLocal;
   if (argc > 1) {
     std::unique_ptr<CFXJSE_Value> argLocal = GetSimpleValue(pThis, args, 1);
     if (FXJSE_Value_IsNull(argLocal.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
       return;
     }
     ValueToUTF8String(argLocal.get(), szLocal);
   }
 
   CFX_ByteString formatStr;
   GetLocalDateFormat(pThis, iStyle, szLocal.AsStringC(), formatStr, FALSE);
-  FXJSE_Value_SetUTF8String(args.GetReturnValue(), formatStr.AsStringC());
+  args.GetReturnValue()->SetString(formatStr.AsStringC());
 }
 
 // static
 void CXFA_FM2JSContext::LocalTimeFmt(CFXJSE_Value* pThis,
                                      const CFX_ByteStringC& szFuncName,
                                      CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if (argc > 2) {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"LocalTimeFmt");
     return;
   }
 
   int32_t iStyle = 0;
   if (argc > 0) {
     std::unique_ptr<CFXJSE_Value> argStyle = GetSimpleValue(pThis, args, 0);
     if (FXJSE_Value_IsNull(argStyle.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
       return;
     }
     iStyle = (int32_t)ValueToFloat(pThis, argStyle.get());
     if (iStyle > 4 || iStyle < 0)
       iStyle = 0;
   }
 
   CFX_ByteString szLocal;
   if (argc > 1) {
     std::unique_ptr<CFXJSE_Value> argLocal = GetSimpleValue(pThis, args, 1);
     if (FXJSE_Value_IsNull(argLocal.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
       return;
     }
     ValueToUTF8String(argLocal.get(), szLocal);
   }
 
   CFX_ByteString formatStr;
   GetLocalTimeFormat(pThis, iStyle, szLocal.AsStringC(), formatStr, FALSE);
-  FXJSE_Value_SetUTF8String(args.GetReturnValue(), formatStr.AsStringC());
+  args.GetReturnValue()->SetString(formatStr.AsStringC());
 }
 
 // static
 void CXFA_FM2JSContext::Num2Date(CFXJSE_Value* pThis,
                                  const CFX_ByteStringC& szFuncName,
                                  CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if (argc < 1 || argc > 3) {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Num2Date");
     return;
   }
 
   std::unique_ptr<CFXJSE_Value> dateValue = GetSimpleValue(pThis, args, 0);
   if (ValueIsNull(pThis, dateValue.get())) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
   int32_t dDate = (int32_t)ValueToFloat(pThis, dateValue.get());
   if (dDate < 1) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
 
   CFX_ByteString formatString;
   if (argc > 1) {
     std::unique_ptr<CFXJSE_Value> formatValue = GetSimpleValue(pThis, args, 1);
     if (ValueIsNull(pThis, formatValue.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
       return;
     }
     ValueToUTF8String(formatValue.get(), formatString);
   }
 
   CFX_ByteString localString;
   if (argc > 2) {
     std::unique_ptr<CFXJSE_Value> localValue = GetSimpleValue(pThis, args, 2);
     if (ValueIsNull(pThis, localValue.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
       return;
     }
     ValueToUTF8String(localValue.get(), localString);
   }
 
   int32_t iYear = 1900;
   int32_t iMonth = 1;
   int32_t iDay = 1;
   int32_t i = 0;
   while (dDate > 0) {
@@ skipping 82 matching lines @@
         }
       }
     }
   }
 
   CFX_ByteString szIsoDateString;
   szIsoDateString.Format("%d%02d%02d", iYear + i, iMonth, iDay);
   CFX_ByteString szLocalDateString;
   IsoDate2Local(pThis, szIsoDateString.AsStringC(), formatString.AsStringC(),
                 localString.AsStringC(), szLocalDateString);
-  FXJSE_Value_SetUTF8String(args.GetReturnValue(),
-                            szLocalDateString.AsStringC());
+  args.GetReturnValue()->SetString(szLocalDateString.AsStringC());
 }
 
 // static
 void CXFA_FM2JSContext::Num2GMTime(CFXJSE_Value* pThis,
                                    const CFX_ByteStringC& szFuncName,
                                    CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if (argc < 1 || argc > 3) {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Num2GMTime");
     return;
   }
 
   std::unique_ptr<CFXJSE_Value> timeValue = GetSimpleValue(pThis, args, 0);
   if (FXJSE_Value_IsNull(timeValue.get())) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
   int32_t iTime = (int32_t)ValueToFloat(pThis, timeValue.get());
   if (FXSYS_abs(iTime) < 1.0) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
 
   CFX_ByteString formatString;
   if (argc > 1) {
     std::unique_ptr<CFXJSE_Value> formatValue = GetSimpleValue(pThis, args, 1);
     if (FXJSE_Value_IsNull(formatValue.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
       return;
     }
     ValueToUTF8String(formatValue.get(), formatString);
   }
 
   CFX_ByteString localString;
   if (argc > 2) {
     std::unique_ptr<CFXJSE_Value> localValue = GetSimpleValue(pThis, args, 2);
     if (FXJSE_Value_IsNull(localValue.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
       return;
     }
     ValueToUTF8String(localValue.get(), localString);
   }
 
   CFX_ByteString szGMTTimeString;
   Num2AllTime(pThis, iTime, formatString.AsStringC(), localString.AsStringC(),
               TRUE, szGMTTimeString);
-  FXJSE_Value_SetUTF8String(args.GetReturnValue(), szGMTTimeString.AsStringC());
+  args.GetReturnValue()->SetString(szGMTTimeString.AsStringC());
 }
 
 // static
 void CXFA_FM2JSContext::Num2Time(CFXJSE_Value* pThis,
                                  const CFX_ByteStringC& szFuncName,
                                  CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if (argc < 1 || argc > 3) {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Num2Time");
     return;
   }
 
   std::unique_ptr<CFXJSE_Value> timeValue = GetSimpleValue(pThis, args, 0);
   if (FXJSE_Value_IsNull(timeValue.get())) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
   FX_FLOAT fTime = ValueToFloat(pThis, timeValue.get());
   if (FXSYS_fabs(fTime) < 1.0) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
 
   CFX_ByteString formatString;
   if (argc > 1) {
     std::unique_ptr<CFXJSE_Value> formatValue = GetSimpleValue(pThis, args, 1);
     if (FXJSE_Value_IsNull(formatValue.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
       return;
     }
     ValueToUTF8String(formatValue.get(), formatString);
   }
 
   CFX_ByteString localString;
   if (argc > 2) {
     std::unique_ptr<CFXJSE_Value> localValue = GetSimpleValue(pThis, args, 2);
     if (FXJSE_Value_IsNull(localValue.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
       return;
     }
     ValueToUTF8String(localValue.get(), localString);
   }
 
   CFX_ByteString szLocalTimeString;
   Num2AllTime(pThis, (int32_t)fTime, formatString.AsStringC(),
               localString.AsStringC(), FALSE, szLocalTimeString);
-  FXJSE_Value_SetUTF8String(args.GetReturnValue(),
-                            szLocalTimeString.AsStringC());
+  args.GetReturnValue()->SetString(szLocalTimeString.AsStringC());
 }
 
 // static
 void CXFA_FM2JSContext::Time(CFXJSE_Value* pThis,
                              const CFX_ByteStringC& szFuncName,
                              CFXJSE_Arguments& args) {
   if (args.GetLength() != 0) {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Time");
     return;
   }
 
   time_t now;
   time(&now);
 
   struct tm* pGmt = gmtime(&now);
-  FXJSE_Value_SetInteger(
-      args.GetReturnValue(),
-      ((pGmt->tm_hour * 3600 + pGmt->tm_min * 60 + pGmt->tm_sec) * 1000));
+  args.GetReturnValue()->SetInteger(
+      (pGmt->tm_hour * 3600 + pGmt->tm_min * 60 + pGmt->tm_sec) * 1000);
 }
 
 // static
 void CXFA_FM2JSContext::Time2Num(CFXJSE_Value* pThis,
                                  const CFX_ByteStringC& szFuncName,
                                  CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if (argc < 1 || argc > 3) {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Time2Num");
     return;
   }
 
   CFX_ByteString timeString;
   std::unique_ptr<CFXJSE_Value> timeValue = GetSimpleValue(pThis, args, 0);
   if (ValueIsNull(pThis, timeValue.get())) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
   ValueToUTF8String(timeValue.get(), timeString);
 
   CFX_ByteString formatString;
   if (argc > 1) {
     std::unique_ptr<CFXJSE_Value> formatValue = GetSimpleValue(pThis, args, 1);
     if (ValueIsNull(pThis, formatValue.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
       return;
     }
     ValueToUTF8String(formatValue.get(), formatString);
   }
 
   CFX_ByteString localString;
   if (argc > 2) {
     std::unique_ptr<CFXJSE_Value> localValue = GetSimpleValue(pThis, args, 2);
     if (ValueIsNull(pThis, localValue.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
       return;
     }
     ValueToUTF8String(localValue.get(), localString);
   }
 
   CXFA_Document* pDoc = ToJSContext(pThis, nullptr)->GetDocument();
   CXFA_LocaleMgr* pMgr = pDoc->GetLocalMgr();
   IFX_Locale* pLocale = nullptr;
   if (localString.IsEmpty()) {
     CXFA_Node* pThisNode = ToNode(pDoc->GetScriptContext()->GetThisObject());
@@ skipping 11 matching lines @@
     pLocale->GetTimePattern(FX_LOCALEDATETIMESUBCATEGORY_Default, wsFormat);
   else
     wsFormat = CFX_WideString::FromUTF8(formatString.AsStringC());
 
   wsFormat = FX_WSTRC(L"time{") + wsFormat;
   wsFormat += FX_WSTRC(L"}");
   CXFA_LocaleValue localeValue(XFA_VT_TIME,
                                CFX_WideString::FromUTF8(timeString.AsStringC()),
                                wsFormat, pLocale, pMgr);
   if (!localeValue.IsValid()) {
-    FXJSE_Value_SetInteger(args.GetReturnValue(), 0);
+    args.GetReturnValue()->SetInteger(0);
     return;
   }
 
   CFX_Unitime uniTime = localeValue.GetTime();
   int32_t hour = uniTime.GetHour();
   int32_t min = uniTime.GetMinute();
   int32_t second = uniTime.GetSecond();
   int32_t milSecond = uniTime.GetMillisecond();
   int32_t mins = hour * 60 + min;
   CXFA_TimeZoneProvider* pProvider = CXFA_TimeZoneProvider::Get();
   if (pProvider) {
     FX_TIMEZONE tz;
     pProvider->GetTimeZone(tz);
     mins -= (tz.tzHour * 60);
     while (mins > 1440)
       mins -= 1440;
     while (mins < 0)
       mins += 1440;
 
     hour = mins / 60;
     min = mins % 60;
   }
-  FXJSE_Value_SetInteger(
-      args.GetReturnValue(),
-      hour * 3600000 + min * 60000 + second * 1000 + milSecond + 1);
+  args.GetReturnValue()->SetInteger(hour * 3600000 + min * 60000 +
+                                    second * 1000 + milSecond + 1);
 }
 
 // static
 void CXFA_FM2JSContext::TimeFmt(CFXJSE_Value* pThis,
                                 const CFX_ByteStringC& szFuncName,
                                 CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if (argc > 2) {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"TimeFmt");
     return;
   }
 
   int32_t iStyle = 0;
   if (argc > 0) {
     std::unique_ptr<CFXJSE_Value> argStyle = GetSimpleValue(pThis, args, 0);
     if (FXJSE_Value_IsNull(argStyle.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
       return;
     }
     iStyle = (int32_t)ValueToFloat(pThis, argStyle.get());
     if (iStyle > 4 || iStyle < 0)
       iStyle = 0;
   }
 
   CFX_ByteString szLocal;
   if (argc > 1) {
     std::unique_ptr<CFXJSE_Value> argLocal = GetSimpleValue(pThis, args, 1);
     if (FXJSE_Value_IsNull(argLocal.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
       return;
     }
     ValueToUTF8String(argLocal.get(), szLocal);
   }
 
   CFX_ByteString formatStr;
   GetStandardTimeFormat(pThis, iStyle, szLocal.AsStringC(), formatStr);
-  FXJSE_Value_SetUTF8String(args.GetReturnValue(), formatStr.AsStringC());
+  args.GetReturnValue()->SetString(formatStr.AsStringC());
 }
 
 // static
 FX_BOOL CXFA_FM2JSContext::IsIsoDateFormat(const FX_CHAR* pData,
                                            int32_t iLength,
                                            int32_t& iStyle,
                                            int32_t& iYear,
                                            int32_t& iMonth,
                                            int32_t& iDay) {
   iYear = 0;
@@ skipping 694 matching lines @@
   if (args.GetLength() != 3) {
     pContext->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Apr");
     return;
   }
 
   std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
   std::unique_ptr<CFXJSE_Value> argTwo = GetSimpleValue(pThis, args, 1);
   std::unique_ptr<CFXJSE_Value> argThree = GetSimpleValue(pThis, args, 2);
   if (ValueIsNull(pThis, argOne.get()) || ValueIsNull(pThis, argTwo.get()) ||
       ValueIsNull(pThis, argThree.get())) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
 
   FX_DOUBLE nPrincipal = ValueToDouble(pThis, argOne.get());
   FX_DOUBLE nPayment = ValueToDouble(pThis, argTwo.get());
   FX_DOUBLE nPeriods = ValueToDouble(pThis, argThree.get());
   if (nPrincipal <= 0 || nPayment <= 0 || nPeriods <= 0) {
     pContext->ThrowException(XFA_IDS_ARGUMENT_MISMATCH);
     return;
   }
 
   FX_DOUBLE r =
       2 * (nPeriods * nPayment - nPrincipal) / (nPeriods * nPrincipal);
   FX_DOUBLE nTemp = 1;
   for (int32_t i = 0; i < nPeriods; ++i)
     nTemp *= (1 + r);
 
   FX_DOUBLE nRet = r * nTemp / (nTemp - 1) - nPayment / nPrincipal;
   while (fabs(nRet) > kFinancialPrecision) {
     FX_DOUBLE nDerivative =
         ((nTemp + r * nPeriods * (nTemp / (1 + r))) * (nTemp - 1) -
          (r * nTemp * nPeriods * (nTemp / (1 + r)))) /
         ((nTemp - 1) * (nTemp - 1));
     if (nDerivative == 0) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
       return;
     }
 
     r = r - nRet / nDerivative;
     nTemp = 1;
     for (int32_t i = 0; i < nPeriods; ++i) {
       nTemp *= (1 + r);
     }
     nRet = r * nTemp / (nTemp - 1) - nPayment / nPrincipal;
   }
-  FXJSE_Value_SetDouble(args.GetReturnValue(), r * 12);
+  args.GetReturnValue()->SetDouble(r * 12);
 }
 
 // static
 void CXFA_FM2JSContext::CTerm(CFXJSE_Value* pThis,
                               const CFX_ByteStringC& szFuncName,
                               CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = ToJSContext(pThis, nullptr);
   if (args.GetLength() != 3) {
     pContext->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"CTerm");
     return;
   }
 
   std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
   std::unique_ptr<CFXJSE_Value> argTwo = GetSimpleValue(pThis, args, 1);
   std::unique_ptr<CFXJSE_Value> argThree = GetSimpleValue(pThis, args, 2);
   if (ValueIsNull(pThis, argOne.get()) || ValueIsNull(pThis, argTwo.get()) ||
       ValueIsNull(pThis, argThree.get())) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
 
   FX_FLOAT nRate = ValueToFloat(pThis, argOne.get());
   FX_FLOAT nFutureValue = ValueToFloat(pThis, argTwo.get());
   FX_FLOAT nInitAmount = ValueToFloat(pThis, argThree.get());
   if ((nRate <= 0) || (nFutureValue <= 0) || (nInitAmount <= 0)) {
     pContext->ThrowException(XFA_IDS_ARGUMENT_MISMATCH);
     return;
   }
 
-  FXJSE_Value_SetFloat(args.GetReturnValue(),
-                       FXSYS_log((FX_FLOAT)(nFutureValue / nInitAmount)) /
-                           FXSYS_log((FX_FLOAT)(1 + nRate)));
+  args.GetReturnValue()->SetFloat(
+      FXSYS_log((FX_FLOAT)(nFutureValue / nInitAmount)) /
+      FXSYS_log((FX_FLOAT)(1 + nRate)));
 }
 
 // static
 void CXFA_FM2JSContext::FV(CFXJSE_Value* pThis,
                            const CFX_ByteStringC& szFuncName,
                            CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = ToJSContext(pThis, nullptr);
   if (args.GetLength() != 3) {
     pContext->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"FV");
     return;
   }
 
   std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
   std::unique_ptr<CFXJSE_Value> argTwo = GetSimpleValue(pThis, args, 1);
   std::unique_ptr<CFXJSE_Value> argThree = GetSimpleValue(pThis, args, 2);
   if (ValueIsNull(pThis, argOne.get()) || ValueIsNull(pThis, argTwo.get()) ||
       ValueIsNull(pThis, argThree.get())) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
 
   FX_DOUBLE nAmount = ValueToDouble(pThis, argOne.get());
   FX_DOUBLE nRate = ValueToDouble(pThis, argTwo.get());
   FX_DOUBLE nPeriod = ValueToDouble(pThis, argThree.get());
   if ((nRate < 0) || (nPeriod <= 0) || (nAmount <= 0)) {
     pContext->ThrowException(XFA_IDS_ARGUMENT_MISMATCH);
     return;
   }
 
   FX_DOUBLE dResult = 0;
   if (nRate) {
     FX_DOUBLE nTemp = 1;
     for (int i = 0; i < nPeriod; ++i) {
       nTemp *= 1 + nRate;
     }
     dResult = nAmount * (nTemp - 1) / nRate;
   } else {
     dResult = nAmount * nPeriod;
   }
 
-  FXJSE_Value_SetDouble(args.GetReturnValue(), dResult);
+  args.GetReturnValue()->SetDouble(dResult);
 }
 
 // static
 void CXFA_FM2JSContext::IPmt(CFXJSE_Value* pThis,
                              const CFX_ByteStringC& szFuncName,
                              CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = ToJSContext(pThis, nullptr);
   if (args.GetLength() != 5) {
     pContext->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"IPmt");
     return;
   }
 
   std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
   std::unique_ptr<CFXJSE_Value> argTwo = GetSimpleValue(pThis, args, 1);
   std::unique_ptr<CFXJSE_Value> argThree = GetSimpleValue(pThis, args, 2);
   std::unique_ptr<CFXJSE_Value> argFour = GetSimpleValue(pThis, args, 3);
   std::unique_ptr<CFXJSE_Value> argFive = GetSimpleValue(pThis, args, 4);
   if (ValueIsNull(pThis, argOne.get()) || ValueIsNull(pThis, argTwo.get()) ||
       ValueIsNull(pThis, argThree.get()) || ValueIsNull(pThis, argFour.get()) ||
       ValueIsNull(pThis, argFive.get())) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
 
   FX_FLOAT nPrincipalAmount = ValueToFloat(pThis, argOne.get());
   FX_FLOAT nRate = ValueToFloat(pThis, argTwo.get());
   FX_FLOAT nPayment = ValueToFloat(pThis, argThree.get());
   FX_FLOAT nFirstMonth = ValueToFloat(pThis, argFour.get());
   FX_FLOAT nNumberOfMonths = ValueToFloat(pThis, argFive.get());
   if ((nPrincipalAmount <= 0) || (nRate <= 0) || (nPayment <= 0) ||
       (nFirstMonth < 0) || (nNumberOfMonths < 0)) {
     pContext->ThrowException(XFA_IDS_ARGUMENT_MISMATCH);
     return;
   }
 
   FX_FLOAT nRateOfMonth = nRate / 12;
   int32_t iNums = (int32_t)(
       (FXSYS_log10((FX_FLOAT)(nPayment / nPrincipalAmount)) -
        FXSYS_log10((FX_FLOAT)(nPayment / nPrincipalAmount - nRateOfMonth))) /
       FXSYS_log10((FX_FLOAT)(1 + nRateOfMonth)));
   int32_t iEnd = std::min((int32_t)(nFirstMonth + nNumberOfMonths - 1), iNums);
 
   if (nPayment < nPrincipalAmount * nRateOfMonth) {
-    FXJSE_Value_SetFloat(args.GetReturnValue(), 0);
+    args.GetReturnValue()->SetFloat(0);
     return;
   }
 
   int32_t i = 0;
   for (i = 0; i < nFirstMonth - 1; ++i)
     nPrincipalAmount -= nPayment - nPrincipalAmount * nRateOfMonth;
 
   FX_FLOAT nSum = 0;
   for (; i < iEnd; ++i) {
     nSum += nPrincipalAmount * nRateOfMonth;
     nPrincipalAmount -= nPayment - nPrincipalAmount * nRateOfMonth;
   }
-  FXJSE_Value_SetFloat(args.GetReturnValue(), nSum);
+  args.GetReturnValue()->SetFloat(nSum);
 }
 
 // static
 void CXFA_FM2JSContext::NPV(CFXJSE_Value* pThis,
                             const CFX_ByteStringC& szFuncName,
                             CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = ToJSContext(pThis, nullptr);
   int32_t argc = args.GetLength();
   if (argc < 3) {
     pContext->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"NPV");
     return;
   }
 
   std::vector<std::unique_ptr<CFXJSE_Value>> argValues;
   for (int32_t i = 0; i < argc; i++) {
     argValues.push_back(GetSimpleValue(pThis, args, i));
     if (ValueIsNull(pThis, argValues[i].get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
       return;
     }
   }
 
   FX_DOUBLE nRate = ValueToDouble(pThis, argValues[0].get());
   if (nRate <= 0) {
     pContext->ThrowException(XFA_IDS_ARGUMENT_MISMATCH);
     return;
   }
 
   std::vector<FX_DOUBLE> data(argc - 1);
   for (int32_t i = 1; i < argc; i++)
     data.push_back(ValueToDouble(pThis, argValues[i].get()));
 
   FX_DOUBLE nSum = 0;
   int32_t iIndex = 0;
   for (int32_t i = 0; i < argc - 1; i++) {
     FX_DOUBLE nTemp = 1;
     for (int32_t j = 0; j <= i; j++)
       nTemp *= 1 + nRate;
 
     FX_DOUBLE nNum = data[iIndex++];
     nSum += nNum / nTemp;
   }
-  FXJSE_Value_SetDouble(args.GetReturnValue(), nSum);
+  args.GetReturnValue()->SetDouble(nSum);
 }
 
 // static
 void CXFA_FM2JSContext::Pmt(CFXJSE_Value* pThis,
                             const CFX_ByteStringC& szFuncName,
                             CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = ToJSContext(pThis, nullptr);
   if (args.GetLength() != 3) {
     pContext->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Pmt");
     return;
   }
 
   std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
   std::unique_ptr<CFXJSE_Value> argTwo = GetSimpleValue(pThis, args, 1);
   std::unique_ptr<CFXJSE_Value> argThree = GetSimpleValue(pThis, args, 2);
   if (ValueIsNull(pThis, argOne.get()) || ValueIsNull(pThis, argTwo.get()) ||
       ValueIsNull(pThis, argThree.get())) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
 
   FX_FLOAT nPrincipal = ValueToFloat(pThis, argOne.get());
   FX_FLOAT nRate = ValueToFloat(pThis, argTwo.get());
   FX_FLOAT nPeriods = ValueToFloat(pThis, argThree.get());
   if ((nPrincipal <= 0) || (nRate <= 0) || (nPeriods <= 0)) {
     pContext->ThrowException(XFA_IDS_ARGUMENT_MISMATCH);
     return;
   }
 
   FX_FLOAT nTmp = 1 + nRate;
   FX_FLOAT nSum = nTmp;
   for (int32_t i = 0; i < nPeriods - 1; ++i)
     nSum *= nTmp;
 
-  FXJSE_Value_SetFloat(args.GetReturnValue(),
-                       (nPrincipal * nRate * nSum) / (nSum - 1));
+  args.GetReturnValue()->SetFloat((nPrincipal * nRate * nSum) / (nSum - 1));
 }
 
 // static
 void CXFA_FM2JSContext::PPmt(CFXJSE_Value* pThis,
                              const CFX_ByteStringC& szFuncName,
                              CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = ToJSContext(pThis, nullptr);
   if (args.GetLength() != 5) {
     pContext->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"PPmt");
     return;
   }
 
   std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
   std::unique_ptr<CFXJSE_Value> argTwo = GetSimpleValue(pThis, args, 1);
   std::unique_ptr<CFXJSE_Value> argThree = GetSimpleValue(pThis, args, 2);
   std::unique_ptr<CFXJSE_Value> argFour = GetSimpleValue(pThis, args, 3);
   std::unique_ptr<CFXJSE_Value> argFive = GetSimpleValue(pThis, args, 4);
   if (ValueIsNull(pThis, argOne.get()) || ValueIsNull(pThis, argTwo.get()) ||
       ValueIsNull(pThis, argThree.get()) || ValueIsNull(pThis, argFour.get()) ||
       ValueIsNull(pThis, argFive.get())) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
 
   FX_FLOAT nPrincipalAmount = ValueToFloat(pThis, argOne.get());
   FX_FLOAT nRate = ValueToFloat(pThis, argTwo.get());
   FX_FLOAT nPayment = ValueToFloat(pThis, argThree.get());
   FX_FLOAT nFirstMonth = ValueToFloat(pThis, argFour.get());
   FX_FLOAT nNumberOfMonths = ValueToFloat(pThis, argFive.get());
   if ((nPrincipalAmount <= 0) || (nRate <= 0) || (nPayment <= 0) ||
       (nFirstMonth < 0) || (nNumberOfMonths < 0)) {
@@ skipping 16 matching lines @@
   for (i = 0; i < nFirstMonth - 1; ++i)
     nPrincipalAmount -= nPayment - nPrincipalAmount * nRateOfMonth;
 
   FX_FLOAT nTemp = 0;
   FX_FLOAT nSum = 0;
   for (; i < iEnd; ++i) {
     nTemp = nPayment - nPrincipalAmount * nRateOfMonth;
     nSum += nTemp;
     nPrincipalAmount -= nTemp;
   }
-  FXJSE_Value_SetFloat(args.GetReturnValue(), nSum);
+  args.GetReturnValue()->SetFloat(nSum);
 }
 
 // static
 void CXFA_FM2JSContext::PV(CFXJSE_Value* pThis,
                            const CFX_ByteStringC& szFuncName,
                            CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = ToJSContext(pThis, nullptr);
   if (args.GetLength() != 3) {
     pContext->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"PV");
     return;
   }
 
   std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
   std::unique_ptr<CFXJSE_Value> argTwo = GetSimpleValue(pThis, args, 1);
   std::unique_ptr<CFXJSE_Value> argThree = GetSimpleValue(pThis, args, 2);
   if (ValueIsNull(pThis, argOne.get()) || ValueIsNull(pThis, argTwo.get()) ||
       ValueIsNull(pThis, argThree.get())) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
 
   FX_DOUBLE nAmount = ValueToDouble(pThis, argOne.get());
   FX_DOUBLE nRate = ValueToDouble(pThis, argTwo.get());
   FX_DOUBLE nPeriod = ValueToDouble(pThis, argThree.get());
   if ((nAmount <= 0) || (nRate < 0) || (nPeriod <= 0)) {
     pContext->ThrowException(XFA_IDS_ARGUMENT_MISMATCH);
     return;
   }
 
   FX_DOUBLE nTemp = 1;
   for (int32_t i = 0; i < nPeriod; ++i)
     nTemp *= 1 + nRate;
 
   nTemp = 1 / nTemp;
-  FXJSE_Value_SetDouble(args.GetReturnValue(), nAmount * ((1 - nTemp) / nRate));
+  args.GetReturnValue()->SetDouble(nAmount * ((1 - nTemp) / nRate));
 }
 
 // static
 void CXFA_FM2JSContext::Rate(CFXJSE_Value* pThis,
                              const CFX_ByteStringC& szFuncName,
                              CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = ToJSContext(pThis, nullptr);
   if (args.GetLength() != 3) {
     pContext->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Rate");
     return;
   }
 
   std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
   std::unique_ptr<CFXJSE_Value> argTwo = GetSimpleValue(pThis, args, 1);
   std::unique_ptr<CFXJSE_Value> argThree = GetSimpleValue(pThis, args, 2);
   if (ValueIsNull(pThis, argOne.get()) || ValueIsNull(pThis, argTwo.get()) ||
       ValueIsNull(pThis, argThree.get())) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
 
   FX_FLOAT nFuture = ValueToFloat(pThis, argOne.get());
   FX_FLOAT nPresent = ValueToFloat(pThis, argTwo.get());
   FX_FLOAT nTotalNumber = ValueToFloat(pThis, argThree.get());
   if ((nFuture <= 0) || (nPresent < 0) || (nTotalNumber <= 0)) {
     pContext->ThrowException(XFA_IDS_ARGUMENT_MISMATCH);
     return;
   }
 
-  FXJSE_Value_SetFloat(
-      args.GetReturnValue(),
-      (FXSYS_pow((FX_FLOAT)(nFuture / nPresent), (FX_FLOAT)(1 / nTotalNumber)) -
-       1));
+  args.GetReturnValue()->SetFloat(
+      FXSYS_pow((FX_FLOAT)(nFuture / nPresent), (FX_FLOAT)(1 / nTotalNumber)) -
+      1);
 }
 
 // static
 void CXFA_FM2JSContext::Term(CFXJSE_Value* pThis,
                              const CFX_ByteStringC& szFuncName,
                              CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = ToJSContext(pThis, nullptr);
   if (args.GetLength() != 3) {
     pContext->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Term");
     return;
   }
 
   std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
   std::unique_ptr<CFXJSE_Value> argTwo = GetSimpleValue(pThis, args, 1);
   std::unique_ptr<CFXJSE_Value> argThree = GetSimpleValue(pThis, args, 2);
   if (ValueIsNull(pThis, argOne.get()) || ValueIsNull(pThis, argTwo.get()) ||
       ValueIsNull(pThis, argThree.get())) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
 
   FX_FLOAT nMount = ValueToFloat(pThis, argOne.get());
   FX_FLOAT nRate = ValueToFloat(pThis, argTwo.get());
   FX_FLOAT nFuture = ValueToFloat(pThis, argThree.get());
   if ((nMount <= 0) || (nRate <= 0) || (nFuture <= 0)) {
     pContext->ThrowException(XFA_IDS_ARGUMENT_MISMATCH);
     return;
   }
 
-  FXJSE_Value_SetFloat(args.GetReturnValue(),
-                       (FXSYS_log((FX_FLOAT)(nFuture / nMount * nRate) + 1) /
-                        FXSYS_log((FX_FLOAT)(1 + nRate))));
+  args.GetReturnValue()->SetFloat(
+      FXSYS_log((FX_FLOAT)(nFuture / nMount * nRate) + 1) /
+      FXSYS_log((FX_FLOAT)(1 + nRate)));
 }
 
 // static
 void CXFA_FM2JSContext::Choose(CFXJSE_Value* pThis,
                                const CFX_ByteStringC& szFuncName,
                                CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = ToJSContext(pThis, nullptr);
   int32_t argc = args.GetLength();
   if (argc < 2) {
     pContext->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Choose");
     return;
   }
 
   std::unique_ptr<CFXJSE_Value> argOne = args.GetValue(0);
   if (ValueIsNull(pThis, argOne.get())) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
 
   int32_t iIndex = (int32_t)ValueToFloat(pThis, argOne.get());
   if (iIndex < 1) {
-    FXJSE_Value_SetUTF8String(args.GetReturnValue(), "");
+    args.GetReturnValue()->SetString("");
     return;
   }
 
   FX_BOOL bFound = FALSE;
   FX_BOOL bStopCounterFlags = FALSE;
   int32_t iArgIndex = 1;
   int32_t iValueIndex = 0;
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   while (!bFound && !bStopCounterFlags && (iArgIndex < argc)) {
     std::unique_ptr<CFXJSE_Value> argIndexValue = args.GetValue(iArgIndex);
     if (FXJSE_Value_IsArray(argIndexValue.get())) {
       std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
-      FXJSE_Value_GetObjectProp(argIndexValue.get(), "length",
-                                lengthValue.get());
-      int32_t iLength = FXJSE_Value_ToInteger(lengthValue.get());
+      argIndexValue->GetObjectProperty("length", lengthValue.get());
+      int32_t iLength = lengthValue->ToInteger();
       if (iLength > 3)
         bStopCounterFlags = TRUE;
 
       iValueIndex += (iLength - 2);
       if (iValueIndex >= iIndex) {
         std::unique_ptr<CFXJSE_Value> propertyValue(new CFXJSE_Value(pIsolate));
         std::unique_ptr<CFXJSE_Value> jsObjectValue(new CFXJSE_Value(pIsolate));
         std::unique_ptr<CFXJSE_Value> newPropertyValue(
             new CFXJSE_Value(pIsolate));
-        FXJSE_Value_GetObjectPropByIdx(argIndexValue.get(), 1,
-                                       propertyValue.get());
-        FXJSE_Value_GetObjectPropByIdx(argIndexValue.get(),
-                                       ((iLength - 1) - (iValueIndex - iIndex)),
-                                       jsObjectValue.get());
+        argIndexValue->GetObjectPropertyByIdx(1, propertyValue.get());
+        argIndexValue->GetObjectPropertyByIdx(
+            (iLength - 1) - (iValueIndex - iIndex), jsObjectValue.get());
         if (FXJSE_Value_IsNull(propertyValue.get())) {
           GetObjectDefaultValue(jsObjectValue.get(), newPropertyValue.get());
         } else {
           CFX_ByteString propStr;
-          FXJSE_Value_ToUTF8String(propertyValue.get(), propStr);
-          FXJSE_Value_GetObjectProp(jsObjectValue.get(), propStr.AsStringC(),
-                                    newPropertyValue.get());
+          propertyValue->ToString(propStr);
+          jsObjectValue->GetObjectProperty(propStr.AsStringC(),
+                                           newPropertyValue.get());
         }
         CFX_ByteString bsChoosed;
         ValueToUTF8String(newPropertyValue.get(), bsChoosed);
-        FXJSE_Value_SetUTF8String(args.GetReturnValue(), bsChoosed.AsStringC());
+        args.GetReturnValue()->SetString(bsChoosed.AsStringC());
         bFound = TRUE;
       }
     } else {
       iValueIndex++;
       if (iValueIndex == iIndex) {
         CFX_ByteString bsChoosed;
         ValueToUTF8String(argIndexValue.get(), bsChoosed);
-        FXJSE_Value_SetUTF8String(args.GetReturnValue(), bsChoosed.AsStringC());
+        args.GetReturnValue()->SetString(bsChoosed.AsStringC());
         bFound = TRUE;
       }
     }
     iArgIndex++;
   }
   if (!bFound)
-    FXJSE_Value_SetUTF8String(args.GetReturnValue(), "");
+    args.GetReturnValue()->SetString("");
 }
 
 // static
 void CXFA_FM2JSContext::Exists(CFXJSE_Value* pThis,
                                const CFX_ByteStringC& szFuncName,
                                CFXJSE_Arguments& args) {
   if (args.GetLength() != 1) {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Exists");
     return;
   }
 
-  FXJSE_Value_SetInteger(args.GetReturnValue(),
-                         FXJSE_Value_IsObject(args.GetValue(0).get()));
+  args.GetReturnValue()->SetInteger(
+      FXJSE_Value_IsObject(args.GetValue(0).get()));
 }
 
 // static
 void CXFA_FM2JSContext::HasValue(CFXJSE_Value* pThis,
                                  const CFX_ByteStringC& szFuncName,
                                  CFXJSE_Arguments& args) {
   if (args.GetLength() != 1) {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"HasValue");
     return;
   }
 
   std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
   if (!FXJSE_Value_IsUTF8String(argOne.get())) {
-    FXJSE_Value_SetInteger(args.GetReturnValue(),
-                           FXJSE_Value_IsNumber(argOne.get()) ||
-                               FXJSE_Value_IsBoolean(argOne.get()));
+    args.GetReturnValue()->SetInteger(FXJSE_Value_IsNumber(argOne.get()) ||
+                                      FXJSE_Value_IsBoolean(argOne.get()));
     return;
   }
 
   CFX_ByteString valueStr;
-  FXJSE_Value_ToUTF8String(argOne.get(), valueStr);
+  argOne->ToString(valueStr);
   valueStr.TrimLeft();
-  FXJSE_Value_SetInteger(args.GetReturnValue(), (!valueStr.IsEmpty()));
+  args.GetReturnValue()->SetInteger(!valueStr.IsEmpty());
 }
 
 // static
 void CXFA_FM2JSContext::Oneof(CFXJSE_Value* pThis,
                               const CFX_ByteStringC& szFuncName,
                               CFXJSE_Arguments& args) {
   if (args.GetLength() < 2) {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Oneof");
     return;
   }
 
   FX_BOOL bFlags = FALSE;
   std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
   CFXJSE_Value** parametersValue = nullptr;
   int32_t iCount = 0;
   unfoldArgs(pThis, args, parametersValue, iCount, 1);
   for (int32_t i = 0; i < iCount; i++) {
     if (simpleValueCompare(pThis, argOne.get(), parametersValue[i])) {
       bFlags = TRUE;
       break;
     }
   }
   for (int32_t i = 0; i < iCount; i++)
     delete parametersValue[i];
   FX_Free(parametersValue);
 
-  FXJSE_Value_SetInteger(args.GetReturnValue(), bFlags);
+  args.GetReturnValue()->SetInteger(bFlags);
 }
 
 // static
 void CXFA_FM2JSContext::Within(CFXJSE_Value* pThis,
                                const CFX_ByteStringC& szFuncName,
                                CFXJSE_Arguments& args) {
   if (args.GetLength() != 3) {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Within");
     return;
   }
 
   std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
   if (FXJSE_Value_IsNull(argOne.get())) {
-    FXJSE_Value_SetUndefined(args.GetReturnValue());
+    args.GetReturnValue()->SetUndefined();
     return;
   }
 
   std::unique_ptr<CFXJSE_Value> argLow = GetSimpleValue(pThis, args, 1);
   std::unique_ptr<CFXJSE_Value> argHigh = GetSimpleValue(pThis, args, 2);
   if (FXJSE_Value_IsNumber(argOne.get())) {
     FX_FLOAT oneNumber = ValueToFloat(pThis, argOne.get());
     FX_FLOAT lowNumber = ValueToFloat(pThis, argLow.get());
     FX_FLOAT heightNumber = ValueToFloat(pThis, argHigh.get());
-    FXJSE_Value_SetInteger(
-        args.GetReturnValue(),
-        ((oneNumber >= lowNumber) && (oneNumber <= heightNumber)));
+    args.GetReturnValue()->SetInteger((oneNumber >= lowNumber) &&
+                                      (oneNumber <= heightNumber));
     return;
   }
 
   CFX_ByteString oneString;
   CFX_ByteString lowString;
   CFX_ByteString heightString;
   ValueToUTF8String(argOne.get(), oneString);
   ValueToUTF8String(argLow.get(), lowString);
   ValueToUTF8String(argHigh.get(), heightString);
-  FXJSE_Value_SetInteger(args.GetReturnValue(),
-                         ((oneString.Compare(lowString.AsStringC()) >= 0) &&
-                          (oneString.Compare(heightString.AsStringC()) <= 0)));
+  args.GetReturnValue()->SetInteger(
+      (oneString.Compare(lowString.AsStringC()) >= 0) &&
+      (oneString.Compare(heightString.AsStringC()) <= 0));
 }
 
 // static
 void CXFA_FM2JSContext::If(CFXJSE_Value* pThis,
                            const CFX_ByteStringC& szFuncName,
                            CFXJSE_Arguments& args) {
   if (args.GetLength() != 3) {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"If");
     return;
   }
 
-  FXJSE_Value_Set(args.GetReturnValue(),
-                  FXJSE_Value_ToBoolean(GetSimpleValue(pThis, args, 0).get())
-                      ? GetSimpleValue(pThis, args, 1).get()
-                      : GetSimpleValue(pThis, args, 2).get());
+  args.GetReturnValue()->Assign(GetSimpleValue(pThis, args, 0)->ToBoolean()
+                                    ? GetSimpleValue(pThis, args, 1).get()
+                                    : GetSimpleValue(pThis, args, 2).get());
 }
 
 // static
 void CXFA_FM2JSContext::Eval(CFXJSE_Value* pThis,
                              const CFX_ByteStringC& szFuncName,
                              CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = ToJSContext(pThis, nullptr);
   if (args.GetLength() != 1) {
     pContext->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Eval");
     return;
   }
 
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   std::unique_ptr<CFXJSE_Value> scriptValue = GetSimpleValue(pThis, args, 0);
   CFX_ByteString utf8ScriptString;
   ValueToUTF8String(scriptValue.get(), utf8ScriptString);
   if (utf8ScriptString.IsEmpty()) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
 
   CFX_WideTextBuf wsJavaScriptBuf;
   CFX_WideString wsError;
   CXFA_FM2JSContext::Translate(
       CFX_WideString::FromUTF8(utf8ScriptString.AsStringC()).AsStringC(),
       wsJavaScriptBuf, wsError);
   CFXJSE_Context* pNewContext =
       FXJSE_Context_Create(pIsolate, nullptr, nullptr);
 
   std::unique_ptr<CFXJSE_Value> returnValue(new CFXJSE_Value(pIsolate));
   CFX_WideString javaScript(wsJavaScriptBuf.AsStringC());
   FXJSE_ExecuteScript(
       pNewContext,
       FX_UTF8Encode(javaScript.c_str(), javaScript.GetLength()).c_str(),
       returnValue.get());
 
-  FXJSE_Value_Set(args.GetReturnValue(), returnValue.get());
+  args.GetReturnValue()->Assign(returnValue.get());
   FXJSE_Context_Release(pNewContext);
 }
 
 // static
 void CXFA_FM2JSContext::Ref(CFXJSE_Value* pThis,
                             const CFX_ByteStringC& szFuncName,
                             CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = ToJSContext(pThis, nullptr);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   if (args.GetLength() != 1) {
     pContext->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Ref");
     return;
   }
 
   std::unique_ptr<CFXJSE_Value> argOne = args.GetValue(0);
   if (!FXJSE_Value_IsArray(argOne.get()) &&
       !FXJSE_Value_IsObject(argOne.get()) &&
       !FXJSE_Value_IsBoolean(argOne.get()) &&
       !FXJSE_Value_IsUTF8String(argOne.get()) &&
       !FXJSE_Value_IsNull(argOne.get()) &&
       !FXJSE_Value_IsNumber(argOne.get())) {
     pContext->ThrowException(XFA_IDS_ARGUMENT_MISMATCH);
     return;
   }
 
   if (FXJSE_Value_IsBoolean(argOne.get()) ||
       FXJSE_Value_IsUTF8String(argOne.get()) ||
       FXJSE_Value_IsNumber(argOne.get())) {
-    FXJSE_Value_Set(args.GetReturnValue(), argOne.get());
+    args.GetReturnValue()->Assign(argOne.get());
     return;
   }
 
   CFXJSE_Value* rgValues[3];
   for (int32_t i = 0; i < 3; i++)
     rgValues[i] = new CFXJSE_Value(pIsolate);
 
   int intVal = 3;
   if (FXJSE_Value_IsNull(argOne.get())) {
     intVal = 4;
-    FXJSE_Value_SetNull(rgValues[2]);
+    rgValues[2]->SetNull();
   } else if (FXJSE_Value_IsArray(argOne.get())) {
 #ifndef NDEBUG
     std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
-    FXJSE_Value_GetObjectProp(argOne.get(), "length", lengthValue.get());
-    ASSERT(FXJSE_Value_ToInteger(lengthValue.get()) >= 3);
+    argOne->GetObjectProperty("length", lengthValue.get());
+    ASSERT(lengthValue->ToInteger() >= 3);
 #endif
 
     std::unique_ptr<CFXJSE_Value> propertyValue(new CFXJSE_Value(pIsolate));
     std::unique_ptr<CFXJSE_Value> jsObjectValue(new CFXJSE_Value(pIsolate));
-    FXJSE_Value_GetObjectPropByIdx(argOne.get(), 1, propertyValue.get());
-    FXJSE_Value_GetObjectPropByIdx(argOne.get(), 2, jsObjectValue.get());
+    argOne->GetObjectPropertyByIdx(1, propertyValue.get());
+    argOne->GetObjectPropertyByIdx(2, jsObjectValue.get());
     if (!FXJSE_Value_IsNull(propertyValue.get()) ||
         FXJSE_Value_IsNull(jsObjectValue.get())) {
       for (int32_t i = 0; i < 3; i++)
         delete rgValues[i];
 
       pContext->ThrowException(XFA_IDS_ARGUMENT_MISMATCH);
       return;
     }
 
-    FXJSE_Value_Set(rgValues[2], jsObjectValue.get());
+    rgValues[2]->Assign(jsObjectValue.get());
   } else if (FXJSE_Value_IsObject(argOne.get())) {
-    FXJSE_Value_Set(rgValues[2], argOne.get());
+    rgValues[2]->Assign(argOne.get());
   }
 
-  FXJSE_Value_SetInteger(rgValues[0], intVal);
-  FXJSE_Value_SetNull(rgValues[1]);
-  FXJSE_Value_SetArray(args.GetReturnValue(), 3, rgValues);
+  rgValues[0]->SetInteger(intVal);
+  rgValues[1]->SetNull();
+  args.GetReturnValue()->SetArray(3, rgValues);
 
   for (int32_t i = 0; i < 3; i++)
     delete rgValues[i];
 }
 
 // static
 void CXFA_FM2JSContext::UnitType(CFXJSE_Value* pThis,
                                  const CFX_ByteStringC& szFuncName,
                                  CFXJSE_Arguments& args) {
   if (args.GetLength() != 1) {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"UnitType");
     return;
   }
 
   std::unique_ptr<CFXJSE_Value> unitspanValue = GetSimpleValue(pThis, args, 0);
   if (FXJSE_Value_IsNull(unitspanValue.get())) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
 
   CFX_ByteString unitspanString;
   ValueToUTF8String(unitspanValue.get(), unitspanString);
   if (unitspanString.IsEmpty()) {
-    FXJSE_Value_SetUTF8String(args.GetReturnValue(), "in");
+    args.GetReturnValue()->SetString("in");
     return;
   }
 
   enum XFA_FM2JS_VALUETYPE_ParserStatus {
     VALUETYPE_START,
     VALUETYPE_HAVEINVALIDCHAR,
     VALUETYPE_HAVEDIGIT,
     VALUETYPE_HAVEDIGITWHITE,
     VALUETYPE_ISCM,
     VALUETYPE_ISMM,
@@ skipping 56 matching lines @@
         }
         break;
       }
     } else {
       eParserStatus = VALUETYPE_HAVEINVALIDCHAR;
     }
     u++;
   }
   switch (eParserStatus) {
     case VALUETYPE_ISCM:
-      FXJSE_Value_SetUTF8String(args.GetReturnValue(), "cm");
+      args.GetReturnValue()->SetString("cm");
       break;
     case VALUETYPE_ISMM:
-      FXJSE_Value_SetUTF8String(args.GetReturnValue(), "mm");
+      args.GetReturnValue()->SetString("mm");
       break;
     case VALUETYPE_ISPT:
-      FXJSE_Value_SetUTF8String(args.GetReturnValue(), "pt");
+      args.GetReturnValue()->SetString("pt");
       break;
     case VALUETYPE_ISMP:
-      FXJSE_Value_SetUTF8String(args.GetReturnValue(), "mp");
+      args.GetReturnValue()->SetString("mp");
       break;
     default:
-      FXJSE_Value_SetUTF8String(args.GetReturnValue(), "in");
+      args.GetReturnValue()->SetString("in");
       break;
   }
 }
 
 // static
 void CXFA_FM2JSContext::UnitValue(CFXJSE_Value* pThis,
                                   const CFX_ByteStringC& szFuncName,
                                   CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if (argc < 1 || argc > 2) {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"UnitValue");
     return;
   }
 
   std::unique_ptr<CFXJSE_Value> unitspanValue = GetSimpleValue(pThis, args, 0);
   if (FXJSE_Value_IsNull(unitspanValue.get())) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
 
   CFX_ByteString unitspanString;
   ValueToUTF8String(unitspanValue.get(), unitspanString);
   const FX_CHAR* pData = unitspanString.c_str();
   if (!pData) {
-    FXJSE_Value_SetInteger(args.GetReturnValue(), 0);
+    args.GetReturnValue()->SetInteger(0);
     return;
   }
 
   int32_t u = 0;
   while (IsWhitespace(pData[u]))
     ++u;
 
   while (u < unitspanString.GetLength()) {
     if ((pData[u] > '9' || pData[u] < '0') && pData[u] != '.' &&
         pData[u] != '-') {
@@ skipping 100 matching lines @@
       dResult = dFirstNumber / 72000 * 25.4;
     else if (strUnit == "cm" || strUnit == "centimeters")
       dResult = dFirstNumber / 72000 * 2.54;
     else if (strUnit == "pt" || strUnit == "points")
       dResult = dFirstNumber / 1000;
     else if (strUnit == "mp" || strUnit == "millipoints")
       dResult = dFirstNumber;
     else
       dResult = dFirstNumber / 72000;
   }
-  FXJSE_Value_SetDouble(args.GetReturnValue(), dResult);
+  args.GetReturnValue()->SetDouble(dResult);
 }
 
 // static
 void CXFA_FM2JSContext::At(CFXJSE_Value* pThis,
                            const CFX_ByteStringC& szFuncName,
                            CFXJSE_Arguments& args) {
   if (args.GetLength() != 2) {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"At");
     return;
   }
 
   std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
   std::unique_ptr<CFXJSE_Value> argTwo = GetSimpleValue(pThis, args, 1);
   if (ValueIsNull(pThis, argOne.get()) || ValueIsNull(pThis, argTwo.get())) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
 
   CFX_ByteString stringTwo;
   ValueToUTF8String(argTwo.get(), stringTwo);
   if (stringTwo.IsEmpty()) {
-    FXJSE_Value_SetInteger(args.GetReturnValue(), 1);
+    args.GetReturnValue()->SetInteger(1);
     return;
   }
 
   CFX_ByteString stringOne;
   ValueToUTF8String(argOne.get(), stringOne);
   FX_STRSIZE iPosition = stringOne.Find(stringTwo.AsStringC());
-  FXJSE_Value_SetInteger(args.GetReturnValue(), iPosition + 1);
+  args.GetReturnValue()->SetInteger(iPosition + 1);
 }
 
 // static
 void CXFA_FM2JSContext::Concat(CFXJSE_Value* pThis,
                                const CFX_ByteStringC& szFuncName,
                                CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if (argc < 1) {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Concat");
     return;
   }
 
   CFX_ByteString resultString;
   FX_BOOL bAllNull = TRUE;
   for (int32_t i = 0; i < argc; i++) {
     std::unique_ptr<CFXJSE_Value> value = GetSimpleValue(pThis, args, i);
     if (ValueIsNull(pThis, value.get()))
       continue;
 
     bAllNull = FALSE;
 
     CFX_ByteString valueStr;
     ValueToUTF8String(value.get(), valueStr);
     resultString += valueStr;
   }
 
   if (bAllNull) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
 
-  FXJSE_Value_SetUTF8String(args.GetReturnValue(), resultString.AsStringC());
+  args.GetReturnValue()->SetString(resultString.AsStringC());
 }
 
 // static
 void CXFA_FM2JSContext::Decode(CFXJSE_Value* pThis,
                                const CFX_ByteStringC& szFuncName,
                                CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if (argc < 1 || argc > 2) {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Decode");
     return;
   }
 
   if (argc == 1) {
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
     if (ValueIsNull(pThis, argOne.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
       return;
     }
 
     CFX_ByteString toDecodeString;
     ValueToUTF8String(argOne.get(), toDecodeString);
     CFX_ByteTextBuf resultBuf;
     DecodeURL(toDecodeString.AsStringC(), resultBuf);
-    FXJSE_Value_SetUTF8String(args.GetReturnValue(), resultBuf.AsStringC());
+    args.GetReturnValue()->SetString(resultBuf.AsStringC());
     return;
   }
 
   std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
   std::unique_ptr<CFXJSE_Value> argTwo = GetSimpleValue(pThis, args, 1);
   if (ValueIsNull(pThis, argOne.get()) || ValueIsNull(pThis, argTwo.get())) {
-    FXJSE_Value_SetNull(args.GetReturnValue());
+    args.GetReturnValue()->SetNull();
     return;
   }
 
   CFX_ByteString toDecodeString;
   ValueToUTF8String(argOne.get(), toDecodeString);
 
   CFX_ByteString identifyString;
   ValueToUTF8String(argTwo.get(), identifyString);
 
   CFX_ByteTextBuf resultBuf;
   if (identifyString.EqualNoCase("html"))
     DecodeHTML(toDecodeString.AsStringC(), resultBuf);
   else if (identifyString.EqualNoCase("xml"))
     DecodeXML(toDecodeString.AsStringC(), resultBuf);
   else
     DecodeURL(toDecodeString.AsStringC(), resultBuf);
 
-  FXJSE_Value_SetUTF8String(args.GetReturnValue(), resultBuf.AsStringC());
+  args.GetReturnValue()->SetString(resultBuf.AsStringC());
 }
 
 // static
 void CXFA_FM2JSContext::DecodeURL(const CFX_ByteStringC& szURLString,
                                   CFX_ByteTextBuf& szResultString) {
   CFX_WideString wsURLString = CFX_WideString::FromUTF8(szURLString);
   const FX_WCHAR* pData = wsURLString.c_str();
   int32_t i = 0;
   CFX_WideTextBuf wsResultBuf;
   while (i < wsURLString.GetLength()) {
@@ skipping 215 matching lines @@
 }
 
 // static
 void CXFA_FM2JSContext::Encode(CFXJSE_Value* pThis,
                                const CFX_ByteStringC& szFuncName,
                                CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if (argc == 1) {
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
     if (ValueIsNull(pThis, argOne.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
     } else {
       CFX_ByteString toEncodeString;
       ValueToUTF8String(argOne.get(), toEncodeString);
       CFX_ByteTextBuf resultBuf;
       EncodeURL(toEncodeString.AsStringC(), resultBuf);
-      FXJSE_Value_SetUTF8String(args.GetReturnValue(), resultBuf.AsStringC());
+      args.GetReturnValue()->SetString(resultBuf.AsStringC());
     }
   } else if (argc == 2) {
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
     std::unique_ptr<CFXJSE_Value> argTwo = GetSimpleValue(pThis, args, 1);
     if (ValueIsNull(pThis, argOne.get()) || ValueIsNull(pThis, argTwo.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
     } else {
       CFX_ByteString toEncodeString;
       ValueToUTF8String(argOne.get(), toEncodeString);
       CFX_ByteString identifyString;
       ValueToUTF8String(argTwo.get(), identifyString);
       CFX_ByteTextBuf resultBuf;
       if (identifyString.EqualNoCase("html")) {
         EncodeHTML(toEncodeString.AsStringC(), resultBuf);
       } else if (identifyString.EqualNoCase("xml")) {
         EncodeXML(toEncodeString.AsStringC(), resultBuf);
       } else {
         EncodeURL(toEncodeString.AsStringC(), resultBuf);
       }
-      FXJSE_Value_SetUTF8String(args.GetReturnValue(), resultBuf.AsStringC());
+      args.GetReturnValue()->SetString(resultBuf.AsStringC());
     }
   } else {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Encode");
   }
 }
 
 // static
 void CXFA_FM2JSContext::EncodeURL(const CFX_ByteStringC& szURLString,
                                   CFX_ByteTextBuf& szResultBuf) {
@@ skipping 351 matching lines @@
             patternType = XFA_VT_TEXT;
           }
         } break;
       }
     }
     CXFA_LocaleValue localeValue(patternType, wsValue, wsPattern, pLocale,
                                  (CXFA_LocaleMgr*)pMgr);
     CFX_WideString wsRet;
     if (localeValue.FormatPatterns(wsRet, wsPattern, pLocale,
                                    XFA_VALUEPICTURE_Display)) {
-      FXJSE_Value_SetUTF8String(
-          args.GetReturnValue(),
+      args.GetReturnValue()->SetString(
           FX_UTF8Encode(wsRet.c_str(), wsRet.GetLength()).AsStringC());
     } else {
-      FXJSE_Value_SetUTF8String(args.GetReturnValue(), "");
+      args.GetReturnValue()->SetString("");
     }
   } else {
     pContext->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Format");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Left(CFXJSE_Value* pThis,
                              const CFX_ByteStringC& szFuncName,
                              CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
     std::unique_ptr<CFXJSE_Value> argTwo = GetSimpleValue(pThis, args, 1);
     FX_BOOL argIsNull = FALSE;
     if ((ValueIsNull(pThis, argOne.get())) ||
         (ValueIsNull(pThis, argTwo.get()))) {
       argIsNull = TRUE;
     }
     if (argIsNull) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
     } else {
       CFX_ByteString sourceString;
       ValueToUTF8String(argOne.get(), sourceString);
       int32_t count = ValueToInteger(pThis, argTwo.get());
       if (count < 0) {
         count = 0;
       }
-      FXJSE_Value_SetUTF8String(args.GetReturnValue(),
-                                sourceString.Left(count).AsStringC());
+      args.GetReturnValue()->SetString(sourceString.Left(count).AsStringC());
     }
   } else {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Left");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Len(CFXJSE_Value* pThis,
                             const CFX_ByteStringC& szFuncName,
                             CFXJSE_Arguments& args) {
   if (args.GetLength() == 1) {
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
     if (ValueIsNull(pThis, argOne.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
     } else {
       CFX_ByteString sourceString;
       ValueToUTF8String(argOne.get(), sourceString);
-      FXJSE_Value_SetInteger(args.GetReturnValue(), sourceString.GetLength());
+      args.GetReturnValue()->SetInteger(sourceString.GetLength());
     }
   } else {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Len");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Lower(CFXJSE_Value* pThis,
                               const CFX_ByteStringC& szFuncName,
                               CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if ((argc > 0) && (argc < 3)) {
     CFX_ByteString argString;
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
     if (ValueIsNull(pThis, argOne.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
     } else {
       ValueToUTF8String(argOne.get(), argString);
       CFX_WideTextBuf lowStringBuf;
       CFX_WideString wsArgString =
           CFX_WideString::FromUTF8(argString.AsStringC());
       const FX_WCHAR* pData = wsArgString.c_str();
       int32_t iLen = argString.GetLength();
       int32_t i = 0;
       int32_t ch = 0;
       while (i < iLen) {
         ch = pData[i];
         if (ch >= 0x41 && ch <= 0x5A) {
           ch += 32;
         } else if (ch >= 0xC0 && ch <= 0xDE) {
           ch += 32;
         } else if (ch == 0x100 || ch == 0x102 || ch == 0x104) {
           ch += 1;
         }
         lowStringBuf.AppendChar(ch);
         ++i;
       }
       lowStringBuf.AppendChar(0);
-      FXJSE_Value_SetUTF8String(
-          args.GetReturnValue(),
+      args.GetReturnValue()->SetString(
           FX_UTF8Encode(lowStringBuf.GetBuffer(), lowStringBuf.GetLength())
               .AsStringC());
     }
   } else {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Lower");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Ltrim(CFXJSE_Value* pThis,
                               const CFX_ByteStringC& szFuncName,
                               CFXJSE_Arguments& args) {
   if (args.GetLength() == 1) {
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
     if (ValueIsNull(pThis, argOne.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
     } else {
       CFX_ByteString sourceString;
       ValueToUTF8String(argOne.get(), sourceString);
       sourceString.TrimLeft();
-      FXJSE_Value_SetUTF8String(args.GetReturnValue(),
-                                sourceString.AsStringC());
+      args.GetReturnValue()->SetString(sourceString.AsStringC());
     }
   } else {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Ltrim");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Parse(CFXJSE_Value* pThis,
                               const CFX_ByteStringC& szFuncName,
                               CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = ToJSContext(pThis, nullptr);
   if (args.GetLength() == 2) {
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
     std::unique_ptr<CFXJSE_Value> argTwo = GetSimpleValue(pThis, args, 1);
     if (ValueIsNull(pThis, argTwo.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
     } else {
       CFX_ByteString szPattern;
       ValueToUTF8String(argOne.get(), szPattern);
       CFX_ByteString szValue;
       ValueToUTF8String(argTwo.get(), szValue);
       CXFA_Document* pDoc = pContext->GetDocument();
       IFX_LocaleMgr* pMgr = (IFX_LocaleMgr*)pDoc->GetLocalMgr();
       CXFA_Node* pThisNode = ToNode(pDoc->GetScriptContext()->GetThisObject());
       ASSERT(pThisNode);
       CXFA_WidgetData widgetData(pThisNode);
       IFX_Locale* pLocale = widgetData.GetLocal();
       uint32_t patternType;
       CFX_WideString wsPattern =
           CFX_WideString::FromUTF8(szPattern.AsStringC());
       CFX_WideString wsValue = CFX_WideString::FromUTF8(szValue.AsStringC());
       CFX_ByteString szParsedValue;
       if (PatternStringType(szPattern.AsStringC(), patternType)) {
         CXFA_LocaleValue localeValue(patternType, wsValue, wsPattern, pLocale,
                                      (CXFA_LocaleMgr*)pMgr);
         if (localeValue.IsValid()) {
           szParsedValue = FX_UTF8Encode(localeValue.GetValue());
-          FXJSE_Value_SetUTF8String(args.GetReturnValue(),
-                                    szParsedValue.AsStringC());
+          args.GetReturnValue()->SetString(szParsedValue.AsStringC());
         } else {
-          FXJSE_Value_SetUTF8String(args.GetReturnValue(), "");
+          args.GetReturnValue()->SetString("");
         }
       } else {
         switch (patternType) {
           case XFA_VT_DATETIME: {
             FX_STRSIZE iTChar = wsPattern.Find(L'T');
             CFX_WideString wsDatePattern(L"date{");
             wsDatePattern += wsPattern.Left(iTChar);
             wsDatePattern += FX_WSTRC(L"} ");
             CFX_WideString wsTimePattern(L"time{");
             wsTimePattern += wsPattern.Mid(iTChar + 1);
             wsTimePattern += FX_WSTRC(L"}");
             wsPattern = wsDatePattern + wsTimePattern;
             CXFA_LocaleValue localeValue(patternType, wsValue, wsPattern,
                                          pLocale, (CXFA_LocaleMgr*)pMgr);
             if (localeValue.IsValid()) {
               szParsedValue = FX_UTF8Encode(localeValue.GetValue());
-              FXJSE_Value_SetUTF8String(args.GetReturnValue(),
-                                        szParsedValue.AsStringC());
+              args.GetReturnValue()->SetString(szParsedValue.AsStringC());
             } else {
-              FXJSE_Value_SetUTF8String(args.GetReturnValue(), "");
+              args.GetReturnValue()->SetString("");
             }
           } break;
           case XFA_VT_DATE: {
             wsPattern = FX_WSTRC(L"date{") + wsPattern;
             wsPattern += FX_WSTRC(L"}");
             CXFA_LocaleValue localeValue(patternType, wsValue, wsPattern,
                                          pLocale, (CXFA_LocaleMgr*)pMgr);
             if (localeValue.IsValid()) {
               szParsedValue = FX_UTF8Encode(localeValue.GetValue());
-              FXJSE_Value_SetUTF8String(args.GetReturnValue(),
-                                        szParsedValue.AsStringC());
+              args.GetReturnValue()->SetString(szParsedValue.AsStringC());
             } else {
-              FXJSE_Value_SetUTF8String(args.GetReturnValue(), "");
+              args.GetReturnValue()->SetString("");
             }
           } break;
           case XFA_VT_TIME: {
             wsPattern = FX_WSTRC(L"time{") + wsPattern;
             wsPattern += FX_WSTRC(L"}");
             CXFA_LocaleValue localeValue(patternType, wsValue, wsPattern,
                                          pLocale, (CXFA_LocaleMgr*)pMgr);
             if (localeValue.IsValid()) {
               szParsedValue = FX_UTF8Encode(localeValue.GetValue());
-              FXJSE_Value_SetUTF8String(args.GetReturnValue(),
-                                        szParsedValue.AsStringC());
+              args.GetReturnValue()->SetString(szParsedValue.AsStringC());
             } else {
-              FXJSE_Value_SetUTF8String(args.GetReturnValue(), "");
+              args.GetReturnValue()->SetString("");
             }
           } break;
           case XFA_VT_TEXT: {
             wsPattern = FX_WSTRC(L"text{") + wsPattern;
             wsPattern += FX_WSTRC(L"}");
             CXFA_LocaleValue localeValue(XFA_VT_TEXT, wsValue, wsPattern,
                                          pLocale, (CXFA_LocaleMgr*)pMgr);
             if (localeValue.IsValid()) {
               szParsedValue = FX_UTF8Encode(localeValue.GetValue());
-              FXJSE_Value_SetUTF8String(args.GetReturnValue(),
-                                        szParsedValue.AsStringC());
+              args.GetReturnValue()->SetString(szParsedValue.AsStringC());
             } else {
-              FXJSE_Value_SetUTF8String(args.GetReturnValue(), "");
+              args.GetReturnValue()->SetString("");
             }
           } break;
           case XFA_VT_FLOAT: {
             wsPattern = FX_WSTRC(L"num{") + wsPattern;
             wsPattern += FX_WSTRC(L"}");
             CXFA_LocaleValue localeValue(XFA_VT_FLOAT, wsValue, wsPattern,
                                          pLocale, (CXFA_LocaleMgr*)pMgr);
             if (localeValue.IsValid()) {
-              FXJSE_Value_SetDouble(args.GetReturnValue(),
-                                    localeValue.GetDoubleNum());
+              args.GetReturnValue()->SetDouble(localeValue.GetDoubleNum());
             } else {
-              FXJSE_Value_SetUTF8String(args.GetReturnValue(), "");
+              args.GetReturnValue()->SetString("");
             }
           } break;
           default: {
             CFX_WideString wsTestPattern;
             wsTestPattern = FX_WSTRC(L"num{") + wsPattern;
             wsTestPattern += FX_WSTRC(L"}");
             CXFA_LocaleValue localeValue(XFA_VT_FLOAT, wsValue, wsTestPattern,
                                          pLocale, (CXFA_LocaleMgr*)pMgr);
             if (localeValue.IsValid()) {
-              FXJSE_Value_SetDouble(args.GetReturnValue(),
-                                    localeValue.GetDoubleNum());
+              args.GetReturnValue()->SetDouble(localeValue.GetDoubleNum());
             } else {
               wsTestPattern = FX_WSTRC(L"text{") + wsPattern;
               wsTestPattern += FX_WSTRC(L"}");
               CXFA_LocaleValue localeValue2(XFA_VT_TEXT, wsValue, wsTestPattern,
                                             pLocale, (CXFA_LocaleMgr*)pMgr);
               if (localeValue2.IsValid()) {
                 szParsedValue = FX_UTF8Encode(localeValue2.GetValue());
-                FXJSE_Value_SetUTF8String(args.GetReturnValue(),
-                                          szParsedValue.AsStringC());
+                args.GetReturnValue()->SetString(szParsedValue.AsStringC());
               } else {
-                FXJSE_Value_SetUTF8String(args.GetReturnValue(), "");
+                args.GetReturnValue()->SetString("");
               }
             }
           } break;
         }
       }
     }
   } else {
     pContext->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Parse");
   }
 }
@@ skipping 44 matching lines @@
           u += iFindLen - 1;
           iFindIndex = 0;
         } else {
           resultString.AppendChar(ch);
         }
       } else {
         resultString.AppendChar(ch);
       }
     }
     resultString.AppendChar(0);
-    FXJSE_Value_SetUTF8String(args.GetReturnValue(), resultString.AsStringC());
+    args.GetReturnValue()->SetString(resultString.AsStringC());
   } else {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Replace");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Right(CFXJSE_Value* pThis,
                               const CFX_ByteStringC& szFuncName,
                               CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
     std::unique_ptr<CFXJSE_Value> argTwo = GetSimpleValue(pThis, args, 1);
     FX_BOOL argIsNull = FALSE;
     if ((ValueIsNull(pThis, argOne.get())) ||
         (ValueIsNull(pThis, argTwo.get()))) {
       argIsNull = TRUE;
     }
     if (argIsNull) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
     } else {
       CFX_ByteString sourceString;
       ValueToUTF8String(argOne.get(), sourceString);
       int32_t count = ValueToInteger(pThis, argTwo.get());
       if (count < 0) {
         count = 0;
       }
-      FXJSE_Value_SetUTF8String(args.GetReturnValue(),
-                                sourceString.Right(count).AsStringC());
+      args.GetReturnValue()->SetString(sourceString.Right(count).AsStringC());
     }
   } else {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Right");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Rtrim(CFXJSE_Value* pThis,
                               const CFX_ByteStringC& szFuncName,
                               CFXJSE_Arguments& args) {
   if (args.GetLength() == 1) {
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
     if (ValueIsNull(pThis, argOne.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
     } else {
       CFX_ByteString sourceString;
       ValueToUTF8String(argOne.get(), sourceString);
       sourceString.TrimRight();
-      FXJSE_Value_SetUTF8String(args.GetReturnValue(),
-                                sourceString.AsStringC());
+      args.GetReturnValue()->SetString(sourceString.AsStringC());
     }
   } else {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Rtrim");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Space(CFXJSE_Value* pThis,
                               const CFX_ByteStringC& szFuncName,
                               CFXJSE_Arguments& args) {
   if (args.GetLength() == 1) {
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
     if (FXJSE_Value_IsNull(argOne.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
     } else {
       int32_t count = 0;
       count = ValueToInteger(pThis, argOne.get());
       count = (count < 0) ? 0 : count;
       CFX_ByteTextBuf spaceString;
       int32_t index = 0;
       while (index < count) {
         spaceString.AppendByte(' ');
         index++;
       }
       spaceString.AppendByte(0);
-      FXJSE_Value_SetUTF8String(args.GetReturnValue(), spaceString.AsStringC());
+      args.GetReturnValue()->SetString(spaceString.AsStringC());
     }
   } else {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Space");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Str(CFXJSE_Value* pThis,
                             const CFX_ByteStringC& szFuncName,
@@ skipping 95 matching lines @@
             ++i;
             ++u;
           }
           while (i < iPrecision) {
             resultBuf.AppendChar('0');
             ++i;
           }
           resultBuf.AppendChar(0);
         }
       }
-      FXJSE_Value_SetUTF8String(args.GetReturnValue(), resultBuf.AsStringC());
+      args.GetReturnValue()->SetString(resultBuf.AsStringC());
     } else {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
     }
   } else {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Str");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Stuff(CFXJSE_Value* pThis,
                               const CFX_ByteStringC& szFuncName,
@@ skipping 37 matching lines @@
       resultString.AppendChar(sourceString.GetAt(i));
       ++i;
     }
     resultString << insertString.AsStringC();
     i = iStart + iDelete;
     while (i < iLength) {
       resultString.AppendChar(sourceString.GetAt(i));
       ++i;
     }
     resultString.AppendChar(0);
-    FXJSE_Value_SetUTF8String(args.GetReturnValue(), resultString.AsStringC());
+    args.GetReturnValue()->SetString(resultString.AsStringC());
   } else {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Stuff");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Substr(CFXJSE_Value* pThis,
                                const CFX_ByteStringC& szFuncName,
                                CFXJSE_Arguments& args) {
   if (args.GetLength() == 3) {
     std::unique_ptr<CFXJSE_Value> stringValue = GetSimpleValue(pThis, args, 0);
     std::unique_ptr<CFXJSE_Value> startValue = GetSimpleValue(pThis, args, 1);
     std::unique_ptr<CFXJSE_Value> endValue = GetSimpleValue(pThis, args, 2);
     if (ValueIsNull(pThis, stringValue.get()) ||
         (ValueIsNull(pThis, startValue.get())) ||
         (ValueIsNull(pThis, endValue.get()))) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
     } else {
       CFX_ByteString szSourceStr;
       int32_t iStart = 0;
       int32_t iCount = 0;
       ValueToUTF8String(stringValue.get(), szSourceStr);
       int32_t iLength = szSourceStr.GetLength();
       if (iLength == 0) {
-        FXJSE_Value_SetUTF8String(args.GetReturnValue(), "");
+        args.GetReturnValue()->SetString("");
       } else {
         iStart = (int32_t)ValueToFloat(pThis, startValue.get());
         iCount = (int32_t)ValueToFloat(pThis, endValue.get());
         if (iStart < 1) {
           iStart = 1;
         }
         if (iStart > iLength) {
           iStart = iLength;
         }
         if (iCount <= 0) {
           iCount = 0;
         }
         iStart -= 1;
-        FXJSE_Value_SetUTF8String(args.GetReturnValue(),
-                                  szSourceStr.Mid(iStart, iCount).AsStringC());
+        args.GetReturnValue()->SetString(
+            szSourceStr.Mid(iStart, iCount).AsStringC());
       }
     }
   } else {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Substr");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Uuid(CFXJSE_Value* pThis,
                              const CFX_ByteStringC& szFuncName,
                              CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if ((argc == 0) || (argc == 1)) {
     int32_t iNum = 0;
     if (argc > 0) {
       std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
       iNum = (int32_t)ValueToFloat(pThis, argOne.get());
     }
     FX_GUID guid;
     FX_GUID_CreateV4(&guid);
     CFX_ByteString bsUId;
     FX_GUID_ToString(&guid, bsUId, iNum);
-    FXJSE_Value_SetUTF8String(args.GetReturnValue(), bsUId.AsStringC());
+    args.GetReturnValue()->SetString(bsUId.AsStringC());
   } else {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Uuid");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Upper(CFXJSE_Value* pThis,
                               const CFX_ByteStringC& szFuncName,
                               CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if ((argc > 0) && (argc < 3)) {
     CFX_ByteString argString;
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
     if (ValueIsNull(pThis, argOne.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
     } else {
       ValueToUTF8String(argOne.get(), argString);
       CFX_WideTextBuf upperStringBuf;
       CFX_WideString wsArgString =
           CFX_WideString::FromUTF8(argString.AsStringC());
       const FX_WCHAR* pData = wsArgString.c_str();
       int32_t iLen = wsArgString.GetLength();
       int32_t i = 0;
       int32_t ch = 0;
       while (i < iLen) {
         ch = pData[i];
         if (ch >= 0x61 && ch <= 0x7A) {
           ch -= 32;
         } else if (ch >= 0xE0 && ch <= 0xFE) {
           ch -= 32;
         } else if (ch == 0x101 || ch == 0x103 || ch == 0x105) {
           ch -= 1;
         }
         upperStringBuf.AppendChar(ch);
         ++i;
       }
       upperStringBuf.AppendChar(0);
-      FXJSE_Value_SetUTF8String(
-          args.GetReturnValue(),
+      args.GetReturnValue()->SetString(
           FX_UTF8Encode(upperStringBuf.GetBuffer(), upperStringBuf.GetLength())
               .AsStringC());
     }
   } else {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Upper");
   }
 }
 
 // static
@@ skipping 25 matching lines @@
       std::unique_ptr<CFXJSE_Value> localeValue =
           GetSimpleValue(pThis, args, 2);
       if (FXJSE_Value_IsNull(localeValue.get())) {
         bFlags = TRUE;
       } else {
         ValueToUTF8String(localeValue.get(), localeString);
       }
     }
     if (!bFlags) {
       if ((fNumber < 0) || (fNumber > 922337203685477550)) {
-        FXJSE_Value_SetUTF8String(args.GetReturnValue(), "*");
+        args.GetReturnValue()->SetString("*");
       } else {
         CFX_ByteTextBuf resultBuf;
         CFX_ByteString numberString;
         numberString.Format("%.2f", fNumber);
         WordUS(numberString.AsStringC(), iIdentifier, resultBuf);
-        FXJSE_Value_SetUTF8String(args.GetReturnValue(), resultBuf.AsStringC());
+        args.GetReturnValue()->SetString(resultBuf.AsStringC());
       }
     } else {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
     }
   } else {
     ToJSContext(pThis, nullptr)
         ->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"WordNum");
   }
 }
 
 // static
 void CXFA_FM2JSContext::TrillionUS(const CFX_ByteStringC& szData,
                                    CFX_ByteTextBuf& strBuf) {
@@ skipping 208 matching lines @@
     }
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
     CFX_ByteString urlString;
     ValueToUTF8String(argOne.get(), urlString);
     IFX_FileRead* pFile = pAppProvider->DownloadURL(
         CFX_WideString::FromUTF8(urlString.AsStringC()));
     if (pFile) {
       int32_t size = pFile->GetSize();
       uint8_t* pData = FX_Alloc(uint8_t, size);
       pFile->ReadBlock(pData, size);
-      FXJSE_Value_SetUTF8String(args.GetReturnValue(),
-                                CFX_ByteStringC(pData, size));
+      args.GetReturnValue()->SetString(CFX_ByteStringC(pData, size));
       FX_Free(pData);
       pFile->Release();
     }
   } else {
     pContext->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Get");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Post(CFXJSE_Value* pThis,
@@ skipping 33 matching lines @@
       ValueToUTF8String(argFive.get(), bsHeader);
     }
     CFX_WideString decodedResponse;
     FX_BOOL bFlags = pAppProvider->PostRequestURL(
         CFX_WideString::FromUTF8(bsURL.AsStringC()),
         CFX_WideString::FromUTF8(bsData.AsStringC()),
         CFX_WideString::FromUTF8(bsContentType.AsStringC()),
         CFX_WideString::FromUTF8(bsEncode.AsStringC()),
         CFX_WideString::FromUTF8(bsHeader.AsStringC()), decodedResponse);
     if (bFlags) {
-      FXJSE_Value_SetUTF8String(
-          args.GetReturnValue(),
+      args.GetReturnValue()->SetString(
           FX_UTF8Encode(decodedResponse.c_str(), decodedResponse.GetLength())
               .AsStringC());
     } else {
       pContext->ThrowException(XFA_IDS_SERVER_DENY);
     }
   } else {
     pContext->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Post");
   }
 }
 
@@ skipping 22 matching lines @@
     ValueToUTF8String(argTwo.get(), bsData);
     if (argc > 2) {
       std::unique_ptr<CFXJSE_Value> argThree = GetSimpleValue(pThis, args, 2);
       ValueToUTF8String(argThree.get(), bsEncode);
     }
     FX_BOOL bFlags = pAppProvider->PutRequestURL(
         CFX_WideString::FromUTF8(bsURL.AsStringC()),
         CFX_WideString::FromUTF8(bsData.AsStringC()),
         CFX_WideString::FromUTF8(bsEncode.AsStringC()));
     if (bFlags) {
-      FXJSE_Value_SetUTF8String(args.GetReturnValue(), "");
+      args.GetReturnValue()->SetString("");
     } else {
       pContext->ThrowException(XFA_IDS_SERVER_DENY);
     }
   } else {
     pContext->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Put");
   }
 }
 
 // static
 void CXFA_FM2JSContext::assign_value_operator(CFXJSE_Value* pThis,
                                               const CFX_ByteStringC& szFuncName,
                                               CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = ToJSContext(pThis, nullptr);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   if (args.GetLength() == 2) {
     std::unique_ptr<CFXJSE_Value> lValue = args.GetValue(0);
     std::unique_ptr<CFXJSE_Value> rValue = GetSimpleValue(pThis, args, 1);
     FX_BOOL bSetStatus = TRUE;
     if (FXJSE_Value_IsArray(lValue.get())) {
       std::unique_ptr<CFXJSE_Value> leftLengthValue(new CFXJSE_Value(pIsolate));
-      FXJSE_Value_GetObjectProp(lValue.get(), "length", leftLengthValue.get());
-      int32_t iLeftLength = FXJSE_Value_ToInteger(leftLengthValue.get());
+      lValue->GetObjectProperty("length", leftLengthValue.get());
+      int32_t iLeftLength = leftLengthValue->ToInteger();
       std::unique_ptr<CFXJSE_Value> jsObjectValue(new CFXJSE_Value(pIsolate));
       std::unique_ptr<CFXJSE_Value> propertyValue(new CFXJSE_Value(pIsolate));
-      FXJSE_Value_GetObjectPropByIdx(lValue.get(), 1, propertyValue.get());
+      lValue->GetObjectPropertyByIdx(1, propertyValue.get());
       if (FXJSE_Value_IsNull(propertyValue.get())) {
         for (int32_t i = 2; i < iLeftLength; i++) {
-          FXJSE_Value_GetObjectPropByIdx(lValue.get(), i, jsObjectValue.get());
+          lValue->GetObjectPropertyByIdx(i, jsObjectValue.get());
           bSetStatus = SetObjectDefaultValue(jsObjectValue.get(), rValue.get());
           if (!bSetStatus) {
             pContext->ThrowException(XFA_IDS_NOT_DEFAUL_VALUE);
             break;
           }
         }
       } else {
         CFX_ByteString propertyStr;
-        FXJSE_Value_ToUTF8String(propertyValue.get(), propertyStr);
+        propertyValue->ToString(propertyStr);
         for (int32_t i = 2; i < iLeftLength; i++) {
-          FXJSE_Value_GetObjectPropByIdx(lValue.get(), i, jsObjectValue.get());
-          FXJSE_Value_SetObjectProp(jsObjectValue.get(),
-                                    propertyStr.AsStringC(), rValue.get());
+          lValue->GetObjectPropertyByIdx(i, jsObjectValue.get());
+          jsObjectValue->SetObjectProperty(propertyStr.AsStringC(),
+                                           rValue.get());
         }
       }
     } else if (FXJSE_Value_IsObject(lValue.get())) {
       bSetStatus = SetObjectDefaultValue(lValue.get(), rValue.get());
       if (!bSetStatus) {
         pContext->ThrowException(XFA_IDS_NOT_DEFAUL_VALUE);
       }
     }
-    FXJSE_Value_Set(args.GetReturnValue(), rValue.get());
+    args.GetReturnValue()->Assign(rValue.get());
   } else {
     pContext->ThrowException(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::logical_or_operator(CFXJSE_Value* pThis,
                                             const CFX_ByteStringC& szFuncName,
                                             CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
     std::unique_ptr<CFXJSE_Value> argFirst = GetSimpleValue(pThis, args, 0);
     std::unique_ptr<CFXJSE_Value> argSecond = GetSimpleValue(pThis, args, 1);
     if (FXJSE_Value_IsNull(argFirst.get()) &&
         FXJSE_Value_IsNull(argSecond.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
     } else {
       FX_FLOAT first = ValueToFloat(pThis, argFirst.get());
       FX_FLOAT second = ValueToFloat(pThis, argSecond.get());
-      FXJSE_Value_SetInteger(args.GetReturnValue(), (first || second) ? 1 : 0);
+      args.GetReturnValue()->SetInteger((first || second) ? 1 : 0);
     }
   } else {
     ToJSContext(pThis, nullptr)->ThrowException(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::logical_and_operator(CFXJSE_Value* pThis,
                                              const CFX_ByteStringC& szFuncName,
                                              CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
     std::unique_ptr<CFXJSE_Value> argFirst = GetSimpleValue(pThis, args, 0);
     std::unique_ptr<CFXJSE_Value> argSecond = GetSimpleValue(pThis, args, 1);
     if (FXJSE_Value_IsNull(argFirst.get()) &&
         FXJSE_Value_IsNull(argSecond.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
     } else {
       FX_FLOAT first = ValueToFloat(pThis, argFirst.get());
       FX_FLOAT second = ValueToFloat(pThis, argSecond.get());
-      FXJSE_Value_SetInteger(args.GetReturnValue(), (first && second) ? 1 : 0);
+      args.GetReturnValue()->SetInteger((first && second) ? 1 : 0);
     }
   } else {
     ToJSContext(pThis, nullptr)->ThrowException(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::equality_operator(CFXJSE_Value* pThis,
                                           const CFX_ByteStringC& szFuncName,
                                           CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
     if (fm_ref_equal(pThis, args)) {
-      FXJSE_Value_SetInteger(args.GetReturnValue(), 1);
+      args.GetReturnValue()->SetInteger(1);
     } else {
       std::unique_ptr<CFXJSE_Value> argFirst = GetSimpleValue(pThis, args, 0);
       std::unique_ptr<CFXJSE_Value> argSecond = GetSimpleValue(pThis, args, 1);
       if (FXJSE_Value_IsNull(argFirst.get()) ||
           FXJSE_Value_IsNull(argSecond.get())) {
-        FXJSE_Value_SetInteger(args.GetReturnValue(),
-                               (FXJSE_Value_IsNull(argFirst.get()) &&
-                                FXJSE_Value_IsNull(argSecond.get()))
-                                   ? 1
-                                   : 0);
+        args.GetReturnValue()->SetInteger((FXJSE_Value_IsNull(argFirst.get()) &&
+                                           FXJSE_Value_IsNull(argSecond.get()))
+                                              ? 1
+                                              : 0);
       } else if (FXJSE_Value_IsUTF8String(argFirst.get()) &&
                  FXJSE_Value_IsUTF8String(argSecond.get())) {
         CFX_ByteString firstOutput;
         CFX_ByteString secondOutput;
-        FXJSE_Value_ToUTF8String(argFirst.get(), firstOutput);
-        FXJSE_Value_ToUTF8String(argSecond.get(), secondOutput);
-        FXJSE_Value_SetInteger(args.GetReturnValue(),
-                               firstOutput == secondOutput);
+        argFirst->ToString(firstOutput);
+        argSecond->ToString(secondOutput);
+        args.GetReturnValue()->SetInteger(firstOutput == secondOutput);
       } else {
         FX_DOUBLE first = ValueToDouble(pThis, argFirst.get());
         FX_DOUBLE second = ValueToDouble(pThis, argSecond.get());
-        FXJSE_Value_SetInteger(args.GetReturnValue(),
-                               (first == second) ? 1 : 0);
+        args.GetReturnValue()->SetInteger((first == second) ? 1 : 0);
       }
     }
   } else {
     ToJSContext(pThis, nullptr)->ThrowException(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::notequality_operator(CFXJSE_Value* pThis,
                                              const CFX_ByteStringC& szFuncName,
                                              CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
     if (fm_ref_equal(pThis, args)) {
-      FXJSE_Value_SetInteger(args.GetReturnValue(), 0);
+      args.GetReturnValue()->SetInteger(0);
     } else {
       std::unique_ptr<CFXJSE_Value> argFirst = GetSimpleValue(pThis, args, 0);
       std::unique_ptr<CFXJSE_Value> argSecond = GetSimpleValue(pThis, args, 1);
       if (FXJSE_Value_IsNull(argFirst.get()) ||
           FXJSE_Value_IsNull(argSecond.get())) {
-        FXJSE_Value_SetInteger(args.GetReturnValue(),
-                               (FXJSE_Value_IsNull(argFirst.get()) &&
-                                FXJSE_Value_IsNull(argSecond.get()))
-                                   ? 0
-                                   : 1);
+        args.GetReturnValue()->SetInteger((FXJSE_Value_IsNull(argFirst.get()) &&
+                                           FXJSE_Value_IsNull(argSecond.get()))
+                                              ? 0
+                                              : 1);
       } else if (FXJSE_Value_IsUTF8String(argFirst.get()) &&
                  FXJSE_Value_IsUTF8String(argSecond.get())) {
         CFX_ByteString firstOutput;
         CFX_ByteString secondOutput;
-        FXJSE_Value_ToUTF8String(argFirst.get(), firstOutput);
-        FXJSE_Value_ToUTF8String(argSecond.get(), secondOutput);
-        FXJSE_Value_SetInteger(args.GetReturnValue(),
-                               firstOutput != secondOutput);
+        argFirst->ToString(firstOutput);
+        argSecond->ToString(secondOutput);
+        args.GetReturnValue()->SetInteger(firstOutput != secondOutput);
       } else {
         FX_DOUBLE first = ValueToDouble(pThis, argFirst.get());
         FX_DOUBLE second = ValueToDouble(pThis, argSecond.get());
-        FXJSE_Value_SetInteger(args.GetReturnValue(), first != second);
+        args.GetReturnValue()->SetInteger(first != second);
       }
     }
   } else {
     ToJSContext(pThis, nullptr)->ThrowException(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 FX_BOOL CXFA_FM2JSContext::fm_ref_equal(CFXJSE_Value* pThis,
                                         CFXJSE_Arguments& args) {
   FX_BOOL bRet = FALSE;
   v8::Isolate* pIsolate = ToJSContext(pThis, nullptr)->GetScriptRuntime();
   std::unique_ptr<CFXJSE_Value> argFirst = args.GetValue(0);
   std::unique_ptr<CFXJSE_Value> argSecond = args.GetValue(1);
   if (FXJSE_Value_IsArray(argFirst.get()) &&
       FXJSE_Value_IsArray(argSecond.get())) {
     std::unique_ptr<CFXJSE_Value> firstFlagValue(new CFXJSE_Value(pIsolate));
     std::unique_ptr<CFXJSE_Value> secondFlagValue(new CFXJSE_Value(pIsolate));
-    FXJSE_Value_GetObjectPropByIdx(argFirst.get(), 0, firstFlagValue.get());
-    FXJSE_Value_GetObjectPropByIdx(argSecond.get(), 0, secondFlagValue.get());
-    if ((FXJSE_Value_ToInteger(firstFlagValue.get()) == 3) &&
-        (FXJSE_Value_ToInteger(secondFlagValue.get()) == 3)) {
+    argFirst->GetObjectPropertyByIdx(0, firstFlagValue.get());
+    argSecond->GetObjectPropertyByIdx(0, secondFlagValue.get());
+    if (firstFlagValue->ToInteger() == 3 && secondFlagValue->ToInteger() == 3) {
       std::unique_ptr<CFXJSE_Value> firstJSObject(new CFXJSE_Value(pIsolate));
       std::unique_ptr<CFXJSE_Value> secondJSObject(new CFXJSE_Value(pIsolate));
-      FXJSE_Value_GetObjectPropByIdx(argFirst.get(), 2, firstJSObject.get());
-      FXJSE_Value_GetObjectPropByIdx(argSecond.get(), 2, secondJSObject.get());
+      argFirst->GetObjectPropertyByIdx(2, firstJSObject.get());
+      argSecond->GetObjectPropertyByIdx(2, secondJSObject.get());
       if (!FXJSE_Value_IsNull(firstJSObject.get()) &&
           !FXJSE_Value_IsNull(secondJSObject.get())) {
         bRet = (firstJSObject->ToHostObject(nullptr) ==
                 secondJSObject->ToHostObject(nullptr));
       }
     }
   }
   return bRet;
 }
 
 // static
 void CXFA_FM2JSContext::less_operator(CFXJSE_Value* pThis,
                                       const CFX_ByteStringC& szFuncName,
                                       CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
     std::unique_ptr<CFXJSE_Value> argFirst = GetSimpleValue(pThis, args, 0);
     std::unique_ptr<CFXJSE_Value> argSecond = GetSimpleValue(pThis, args, 1);
     if (FXJSE_Value_IsNull(argFirst.get()) ||
         FXJSE_Value_IsNull(argSecond.get())) {
-      FXJSE_Value_SetInteger(args.GetReturnValue(), 0);
+      args.GetReturnValue()->SetInteger(0);
     } else if (FXJSE_Value_IsUTF8String(argFirst.get()) &&
                FXJSE_Value_IsUTF8String(argSecond.get())) {
       CFX_ByteString firstOutput;
       CFX_ByteString secondOutput;
-      FXJSE_Value_ToUTF8String(argFirst.get(), firstOutput);
-      FXJSE_Value_ToUTF8String(argSecond.get(), secondOutput);
-      FXJSE_Value_SetInteger(
-          args.GetReturnValue(),
+      argFirst->ToString(firstOutput);
+      argSecond->ToString(secondOutput);
+      args.GetReturnValue()->SetInteger(
           firstOutput.Compare(secondOutput.AsStringC()) == -1);
     } else {
       FX_DOUBLE first = ValueToDouble(pThis, argFirst.get());
       FX_DOUBLE second = ValueToDouble(pThis, argSecond.get());
-      FXJSE_Value_SetInteger(args.GetReturnValue(), (first < second) ? 1 : 0);
+      args.GetReturnValue()->SetInteger((first < second) ? 1 : 0);
     }
   } else {
     ToJSContext(pThis, nullptr)->ThrowException(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::lessequal_operator(CFXJSE_Value* pThis,
                                            const CFX_ByteStringC& szFuncName,
                                            CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
     std::unique_ptr<CFXJSE_Value> argFirst = GetSimpleValue(pThis, args, 0);
     std::unique_ptr<CFXJSE_Value> argSecond = GetSimpleValue(pThis, args, 1);
     if (FXJSE_Value_IsNull(argFirst.get()) ||
         FXJSE_Value_IsNull(argSecond.get())) {
-      FXJSE_Value_SetInteger(args.GetReturnValue(),
-                             (FXJSE_Value_IsNull(argFirst.get()) &&
-                              FXJSE_Value_IsNull(argSecond.get()))
-                                 ? 1
-                                 : 0);
+      args.GetReturnValue()->SetInteger((FXJSE_Value_IsNull(argFirst.get()) &&
+                                         FXJSE_Value_IsNull(argSecond.get()))
+                                            ? 1
+                                            : 0);
     } else if (FXJSE_Value_IsUTF8String(argFirst.get()) &&
                FXJSE_Value_IsUTF8String(argSecond.get())) {
       CFX_ByteString firstOutput;
       CFX_ByteString secondOutput;
-      FXJSE_Value_ToUTF8String(argFirst.get(), firstOutput);
-      FXJSE_Value_ToUTF8String(argSecond.get(), secondOutput);
-      FXJSE_Value_SetInteger(
-          args.GetReturnValue(),
+      argFirst->ToString(firstOutput);
+      argSecond->ToString(secondOutput);
+      args.GetReturnValue()->SetInteger(
           firstOutput.Compare(secondOutput.AsStringC()) != 1);
     } else {
       FX_DOUBLE first = ValueToDouble(pThis, argFirst.get());
       FX_DOUBLE second = ValueToDouble(pThis, argSecond.get());
-      FXJSE_Value_SetInteger(args.GetReturnValue(), (first <= second) ? 1 : 0);
+      args.GetReturnValue()->SetInteger((first <= second) ? 1 : 0);
     }
   } else {
     ToJSContext(pThis, nullptr)->ThrowException(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::greater_operator(CFXJSE_Value* pThis,
                                          const CFX_ByteStringC& szFuncName,
                                          CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
     std::unique_ptr<CFXJSE_Value> argFirst = GetSimpleValue(pThis, args, 0);
     std::unique_ptr<CFXJSE_Value> argSecond = GetSimpleValue(pThis, args, 1);
     if (FXJSE_Value_IsNull(argFirst.get()) ||
         FXJSE_Value_IsNull(argSecond.get())) {
-      FXJSE_Value_SetInteger(args.GetReturnValue(), 0);
+      args.GetReturnValue()->SetInteger(0);
     } else if (FXJSE_Value_IsUTF8String(argFirst.get()) &&
                FXJSE_Value_IsUTF8String(argSecond.get())) {
       CFX_ByteString firstOutput;
       CFX_ByteString secondOutput;
-      FXJSE_Value_ToUTF8String(argFirst.get(), firstOutput);
-      FXJSE_Value_ToUTF8String(argSecond.get(), secondOutput);
-      FXJSE_Value_SetInteger(
-          args.GetReturnValue(),
+      argFirst->ToString(firstOutput);
+      argSecond->ToString(secondOutput);
+      args.GetReturnValue()->SetInteger(
           firstOutput.Compare(secondOutput.AsStringC()) == 1);
     } else {
       FX_DOUBLE first = ValueToDouble(pThis, argFirst.get());
       FX_DOUBLE second = ValueToDouble(pThis, argSecond.get());
-      FXJSE_Value_SetInteger(args.GetReturnValue(), (first > second) ? 1 : 0);
+      args.GetReturnValue()->SetInteger((first > second) ? 1 : 0);
     }
   } else {
     ToJSContext(pThis, nullptr)->ThrowException(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::greaterequal_operator(CFXJSE_Value* pThis,
                                               const CFX_ByteStringC& szFuncName,
                                               CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
     std::unique_ptr<CFXJSE_Value> argFirst = GetSimpleValue(pThis, args, 0);
     std::unique_ptr<CFXJSE_Value> argSecond = GetSimpleValue(pThis, args, 1);
     if (FXJSE_Value_IsNull(argFirst.get()) ||
         FXJSE_Value_IsNull(argSecond.get())) {
-      FXJSE_Value_SetInteger(args.GetReturnValue(),
-                             (FXJSE_Value_IsNull(argFirst.get()) &&
-                              FXJSE_Value_IsNull(argSecond.get()))
-                                 ? 1
-                                 : 0);
+      args.GetReturnValue()->SetInteger((FXJSE_Value_IsNull(argFirst.get()) &&
+                                         FXJSE_Value_IsNull(argSecond.get()))
+                                            ? 1
+                                            : 0);
     } else if (FXJSE_Value_IsUTF8String(argFirst.get()) &&
                FXJSE_Value_IsUTF8String(argSecond.get())) {
       CFX_ByteString firstOutput;
       CFX_ByteString secondOutput;
-      FXJSE_Value_ToUTF8String(argFirst.get(), firstOutput);
-      FXJSE_Value_ToUTF8String(argSecond.get(), secondOutput);
-      FXJSE_Value_SetInteger(
-          args.GetReturnValue(),
+      argFirst->ToString(firstOutput);
+      argSecond->ToString(secondOutput);
+      args.GetReturnValue()->SetInteger(
           firstOutput.Compare(secondOutput.AsStringC()) != -1);
     } else {
       FX_DOUBLE first = ValueToDouble(pThis, argFirst.get());
       FX_DOUBLE second = ValueToDouble(pThis, argSecond.get());
-      FXJSE_Value_SetInteger(args.GetReturnValue(), (first >= second) ? 1 : 0);
+      args.GetReturnValue()->SetInteger((first >= second) ? 1 : 0);
     }
   } else {
     ToJSContext(pThis, nullptr)->ThrowException(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::plus_operator(CFXJSE_Value* pThis,
                                       const CFX_ByteStringC& szFuncName,
                                       CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
     std::unique_ptr<CFXJSE_Value> argFirst = args.GetValue(0);
     std::unique_ptr<CFXJSE_Value> argSecond = args.GetValue(1);
     if (ValueIsNull(pThis, argFirst.get()) &&
         ValueIsNull(pThis, argSecond.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
     } else {
       FX_DOUBLE first = ValueToDouble(pThis, argFirst.get());
       FX_DOUBLE second = ValueToDouble(pThis, argSecond.get());
-      FXJSE_Value_SetDouble(args.GetReturnValue(), first + second);
+      args.GetReturnValue()->SetDouble(first + second);
     }
   } else {
     ToJSContext(pThis, nullptr)->ThrowException(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::minus_operator(CFXJSE_Value* pThis,
                                        const CFX_ByteStringC& szFuncName,
                                        CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
     std::unique_ptr<CFXJSE_Value> argFirst = GetSimpleValue(pThis, args, 0);
     std::unique_ptr<CFXJSE_Value> argSecond = GetSimpleValue(pThis, args, 1);
     if (FXJSE_Value_IsNull(argFirst.get()) &&
         FXJSE_Value_IsNull(argSecond.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
     } else {
       FX_DOUBLE first = ValueToDouble(pThis, argFirst.get());
       FX_DOUBLE second = ValueToDouble(pThis, argSecond.get());
-      FXJSE_Value_SetDouble(args.GetReturnValue(), first - second);
+      args.GetReturnValue()->SetDouble(first - second);
     }
   } else {
     ToJSContext(pThis, nullptr)->ThrowException(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::multiple_operator(CFXJSE_Value* pThis,
                                           const CFX_ByteStringC& szFuncName,
                                           CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
     std::unique_ptr<CFXJSE_Value> argFirst = GetSimpleValue(pThis, args, 0);
     std::unique_ptr<CFXJSE_Value> argSecond = GetSimpleValue(pThis, args, 1);
     if (FXJSE_Value_IsNull(argFirst.get()) &&
         FXJSE_Value_IsNull(argSecond.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
     } else {
       FX_DOUBLE first = ValueToDouble(pThis, argFirst.get());
       FX_DOUBLE second = ValueToDouble(pThis, argSecond.get());
-      FXJSE_Value_SetDouble(args.GetReturnValue(), first * second);
+      args.GetReturnValue()->SetDouble(first * second);
     }
   } else {
     ToJSContext(pThis, nullptr)->ThrowException(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::divide_operator(CFXJSE_Value* pThis,
                                         const CFX_ByteStringC& szFuncName,
                                         CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = ToJSContext(pThis, nullptr);
   if (args.GetLength() == 2) {
     std::unique_ptr<CFXJSE_Value> argFirst = GetSimpleValue(pThis, args, 0);
     std::unique_ptr<CFXJSE_Value> argSecond = GetSimpleValue(pThis, args, 1);
     if (FXJSE_Value_IsNull(argFirst.get()) &&
         FXJSE_Value_IsNull(argSecond.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
     } else {
       FX_DOUBLE first = ValueToDouble(pThis, argFirst.get());
       FX_DOUBLE second = ValueToDouble(pThis, argSecond.get());
       if (second == 0.0) {
         pContext->ThrowException(XFA_IDS_DIVIDE_ZERO);
       } else {
-        FXJSE_Value_SetDouble(args.GetReturnValue(), first / second);
+        args.GetReturnValue()->SetDouble(first / second);
       }
     }
   } else {
     pContext->ThrowException(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::positive_operator(CFXJSE_Value* pThis,
                                           const CFX_ByteStringC& szFuncName,
                                           CFXJSE_Arguments& args) {
   if (args.GetLength() == 1) {
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
     if (FXJSE_Value_IsNull(argOne.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
     } else {
-      FXJSE_Value_SetDouble(args.GetReturnValue(),
-                            0.0 + ValueToDouble(pThis, argOne.get()));
+      args.GetReturnValue()->SetDouble(0.0 +
+                                       ValueToDouble(pThis, argOne.get()));
     }
   } else {
     ToJSContext(pThis, nullptr)->ThrowException(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::negative_operator(CFXJSE_Value* pThis,
                                           const CFX_ByteStringC& szFuncName,
                                           CFXJSE_Arguments& args) {
   if (args.GetLength() == 1) {
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
     if (FXJSE_Value_IsNull(argOne.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
     } else {
-      FXJSE_Value_SetDouble(args.GetReturnValue(),
-                            0.0 - ValueToDouble(pThis, argOne.get()));
+      args.GetReturnValue()->SetDouble(0.0 -
+                                       ValueToDouble(pThis, argOne.get()));
     }
   } else {
     ToJSContext(pThis, nullptr)->ThrowException(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::logical_not_operator(CFXJSE_Value* pThis,
                                              const CFX_ByteStringC& szFuncName,
                                              CFXJSE_Arguments& args) {
   if (args.GetLength() == 1) {
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
     if (FXJSE_Value_IsNull(argOne.get())) {
-      FXJSE_Value_SetNull(args.GetReturnValue());
+      args.GetReturnValue()->SetNull();
     } else {
       FX_DOUBLE first = ValueToDouble(pThis, argOne.get());
-      FXJSE_Value_SetInteger(args.GetReturnValue(), (first == 0.0) ? 1 : 0);
+      args.GetReturnValue()->SetInteger((first == 0.0) ? 1 : 0);
     }
   } else {
     ToJSContext(pThis, nullptr)->ThrowException(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::dot_accessor(CFXJSE_Value* pThis,
                                      const CFX_ByteStringC& szFuncName,
                                      CFXJSE_Arguments& args) {
@@ skipping 10 matching lines @@
     if (argc > 4) {
       bIsStar = FALSE;
       std::unique_ptr<CFXJSE_Value> argIndex = args.GetValue(4);
       iIndexValue = ValueToInteger(pThis, argIndex.get());
     }
     CFX_ByteString szSomExp;
     GenerateSomExpression(szName.AsStringC(), iIndexFlags, iIndexValue, bIsStar,
                           szSomExp);
     if (FXJSE_Value_IsArray(argAccessor.get())) {
       std::unique_ptr<CFXJSE_Value> pLengthValue(new CFXJSE_Value(pIsolate));
-      FXJSE_Value_GetObjectProp(argAccessor.get(), "length",
-                                pLengthValue.get());
-      int32_t iLength = FXJSE_Value_ToInteger(pLengthValue.get());
+      argAccessor->GetObjectProperty("length", pLengthValue.get());
+      int32_t iLength = pLengthValue->ToInteger();
       int32_t iCounter = 0;
       CFXJSE_Value*** hResolveValues = FX_Alloc(CFXJSE_Value**, iLength - 2);
       int32_t* iSizes = FX_Alloc(int32_t, iLength - 2);
       for (int32_t i = 0; i < (iLength - 2); i++) {
         iSizes[i] = 0;
       }
       std::unique_ptr<CFXJSE_Value> hJSObjValue(new CFXJSE_Value(pIsolate));
       FX_BOOL bAttribute = FALSE;
       for (int32_t i = 2; i < iLength; i++) {
-        FXJSE_Value_GetObjectPropByIdx(argAccessor.get(), i, hJSObjValue.get());
+        argAccessor->GetObjectPropertyByIdx(i, hJSObjValue.get());
         XFA_RESOLVENODE_RS resoveNodeRS;
         int32_t iRet =
             ResolveObjects(pThis, hJSObjValue.get(), szSomExp.AsStringC(),
                            resoveNodeRS, TRUE, szName.IsEmpty());
         if (iRet > 0) {
           ParseResolveResult(pThis, resoveNodeRS, hJSObjValue.get(),
                              hResolveValues[i - 2], iSizes[i - 2], bAttribute);
           iCounter += iSizes[i - 2];
         }
       }
       if (iCounter > 0) {
         CFXJSE_Value** rgValues = FX_Alloc(CFXJSE_Value*, iCounter + 2);
         for (int32_t i = 0; i < (iCounter + 2); i++)
           rgValues[i] = new CFXJSE_Value(pIsolate);
 
-        FXJSE_Value_SetInteger(rgValues[0], 1);
+        rgValues[0]->SetInteger(1);
         if (bAttribute) {
-          FXJSE_Value_SetUTF8String(rgValues[1], szName.AsStringC());
+          rgValues[1]->SetString(szName.AsStringC());
         } else {
-          FXJSE_Value_SetNull(rgValues[1]);
+          rgValues[1]->SetNull();
         }
         int32_t iIndex = 2;
         for (int32_t i = 0; i < iLength - 2; i++) {
           for (int32_t j = 0; j < iSizes[i]; j++) {
-            FXJSE_Value_Set(rgValues[iIndex], hResolveValues[i][j]);
+            rgValues[iIndex]->Assign(hResolveValues[i][j]);
             iIndex++;
           }
         }
-        FXJSE_Value_SetArray(args.GetReturnValue(), (iCounter + 2), rgValues);
+        args.GetReturnValue()->SetArray(iCounter + 2, rgValues);
         for (int32_t i = 0; i < (iCounter + 2); i++)
           delete rgValues[i];
 
         FX_Free(rgValues);
       } else {
         CFX_WideString wsPropertyName =
             CFX_WideString::FromUTF8(szName.AsStringC());
         CFX_WideString wsSomExpression =
             CFX_WideString::FromUTF8(szSomExp.AsStringC());
         pContext->ThrowException(XFA_IDS_ACCESS_PROPERTY_IN_NOT_OBJECT,
@@ skipping 29 matching lines @@
       if (iRet > 0) {
         CFXJSE_Value** hResolveValues;
         int32_t iSize = 0;
         FX_BOOL bAttribute = FALSE;
         ParseResolveResult(pThis, resoveNodeRS, argAccessor.get(),
                            hResolveValues, iSize, bAttribute);
         CFXJSE_Value** rgValues = FX_Alloc(CFXJSE_Value*, iSize + 2);
         for (int32_t i = 0; i < (iSize + 2); i++)
           rgValues[i] = new CFXJSE_Value(pIsolate);
 
-        FXJSE_Value_SetInteger(rgValues[0], 1);
+        rgValues[0]->SetInteger(1);
         if (bAttribute) {
-          FXJSE_Value_SetUTF8String(rgValues[1], szName.AsStringC());
+          rgValues[1]->SetString(szName.AsStringC());
         } else {
-          FXJSE_Value_SetNull(rgValues[1]);
+          rgValues[1]->SetNull();
         }
         for (int32_t i = 0; i < iSize; i++) {
-          FXJSE_Value_Set(rgValues[i + 2], hResolveValues[i]);
+          rgValues[i + 2]->Assign(hResolveValues[i]);
         }
-        FXJSE_Value_SetArray(args.GetReturnValue(), (iSize + 2), rgValues);
+        args.GetReturnValue()->SetArray(iSize + 2, rgValues);
         for (int32_t i = 0; i < (iSize + 2); i++)
           delete rgValues[i];
 
         FX_Free(rgValues);
         for (int32_t i = 0; i < iSize; i++)
           delete hResolveValues[i];
 
         FX_Free(hResolveValues);
       } else {
         CFX_WideString wsPropertyName =
@@ skipping 27 matching lines @@
     if (argc > 4) {
       bIsStar = FALSE;
       std::unique_ptr<CFXJSE_Value> argIndex = args.GetValue(4);
       iIndexValue = ValueToInteger(pThis, argIndex.get());
     }
     CFX_ByteString szSomExp;
     GenerateSomExpression(szName.AsStringC(), iIndexFlags, iIndexValue, bIsStar,
                           szSomExp);
     if (FXJSE_Value_IsArray(argAccessor.get())) {
       std::unique_ptr<CFXJSE_Value> pLengthValue(new CFXJSE_Value(pIsolate));
-      FXJSE_Value_GetObjectProp(argAccessor.get(), "length",
-                                pLengthValue.get());
-      int32_t iLength = FXJSE_Value_ToInteger(pLengthValue.get());
+      argAccessor->GetObjectProperty("length", pLengthValue.get());
+      int32_t iLength = pLengthValue->ToInteger();
       int32_t iCounter = 0;
       CFXJSE_Value*** hResolveValues = FX_Alloc(CFXJSE_Value**, iLength - 2);
       int32_t* iSizes = FX_Alloc(int32_t, iLength - 2);
       std::unique_ptr<CFXJSE_Value> hJSObjValue(new CFXJSE_Value(pIsolate));
       FX_BOOL bAttribute = FALSE;
       for (int32_t i = 2; i < iLength; i++) {
-        FXJSE_Value_GetObjectPropByIdx(argAccessor.get(), i, hJSObjValue.get());
+        argAccessor->GetObjectPropertyByIdx(i, hJSObjValue.get());
         XFA_RESOLVENODE_RS resoveNodeRS;
         int32_t iRet =
             ResolveObjects(pThis, hJSObjValue.get(), szSomExp.AsStringC(),
                            resoveNodeRS, FALSE);
         if (iRet > 0) {
           ParseResolveResult(pThis, resoveNodeRS, hJSObjValue.get(),
                              hResolveValues[i - 2], iSizes[i - 2], bAttribute);
           iCounter += iSizes[i - 2];
         }
       }
       if (iCounter > 0) {
         CFXJSE_Value** rgValues = FX_Alloc(CFXJSE_Value*, iCounter + 2);
         for (int32_t i = 0; i < (iCounter + 2); i++)
           rgValues[i] = new CFXJSE_Value(pIsolate);
 
-        FXJSE_Value_SetInteger(rgValues[0], 1);
+        rgValues[0]->SetInteger(1);
         if (bAttribute) {
-          FXJSE_Value_SetUTF8String(rgValues[1], szName.AsStringC());
+          rgValues[1]->SetString(szName.AsStringC());
         } else {
-          FXJSE_Value_SetNull(rgValues[1]);
+          rgValues[1]->SetNull();
         }
         int32_t iIndex = 2;
         for (int32_t i = 0; i < iLength - 2; i++) {
           for (int32_t j = 0; j < iSizes[i]; j++) {
-            FXJSE_Value_Set(rgValues[iIndex], hResolveValues[i][j]);
+            rgValues[iIndex]->Assign(hResolveValues[i][j]);
             iIndex++;
           }
         }
-        FXJSE_Value_SetArray(args.GetReturnValue(), (iCounter + 2), rgValues);
+        args.GetReturnValue()->SetArray(iCounter + 2, rgValues);
         for (int32_t i = 0; i < (iCounter + 2); i++)
           delete rgValues[i];
 
         FX_Free(rgValues);
       } else {
         CFX_WideString wsPropertyName =
             CFX_WideString::FromUTF8(szName.AsStringC());
         CFX_WideString wsSomExpression =
             CFX_WideString::FromUTF8(szSomExp.AsStringC());
         pContext->ThrowException(XFA_IDS_ACCESS_PROPERTY_IN_NOT_OBJECT,
@@ skipping 27 matching lines @@
       if (iRet > 0) {
         CFXJSE_Value** hResolveValues;
         int32_t iSize = 0;
         FX_BOOL bAttribute = FALSE;
         ParseResolveResult(pThis, resoveNodeRS, argAccessor.get(),
                            hResolveValues, iSize, bAttribute);
         CFXJSE_Value** rgValues = FX_Alloc(CFXJSE_Value*, iSize + 2);
         for (int32_t i = 0; i < (iSize + 2); i++)
           rgValues[i] = new CFXJSE_Value(pIsolate);
 
-        FXJSE_Value_SetInteger(rgValues[0], 1);
+        rgValues[0]->SetInteger(1);
         if (bAttribute) {
-          FXJSE_Value_SetUTF8String(rgValues[1], szName.AsStringC());
+          rgValues[1]->SetString(szName.AsStringC());
         } else {
-          FXJSE_Value_SetNull(rgValues[1]);
+          rgValues[1]->SetNull();
         }
         for (int32_t i = 0; i < iSize; i++) {
-          FXJSE_Value_Set(rgValues[i + 2], hResolveValues[i]);
+          rgValues[i + 2]->Assign(hResolveValues[i]);
         }
-        FXJSE_Value_SetArray(args.GetReturnValue(), (iSize + 2), rgValues);
+        args.GetReturnValue()->SetArray(iSize + 2, rgValues);
         for (int32_t i = 0; i < (iSize + 2); i++)
           delete rgValues[i];
 
         FX_Free(rgValues);
         for (int32_t i = 0; i < iSize; i++)
           delete hResolveValues[i];
 
         FX_Free(hResolveValues);
       } else {
         CFX_WideString wsPropertyName =
@@ skipping 23 matching lines @@
       pContext->ThrowException(XFA_IDS_ARGUMENT_MISMATCH);
     } else {
       CFX_WideString scriptString =
           CFX_WideString::FromUTF8(argString.AsStringC());
       CFX_WideTextBuf wsJavaScriptBuf;
       CFX_WideString wsError;
       CXFA_FM2JSContext::Translate(scriptString.AsStringC(), wsJavaScriptBuf,
                                    wsError);
       if (wsError.IsEmpty()) {
         CFX_WideString javaScript = wsJavaScriptBuf.MakeString();
-        FXJSE_Value_SetUTF8String(
-            args.GetReturnValue(),
+        args.GetReturnValue()->SetString(
             FX_UTF8Encode(javaScript.c_str(), javaScript.GetLength())
                 .AsStringC());
       } else {
         pContext->ThrowException(XFA_IDS_COMPILER_ERROR);
       }
     }
   } else {
     pContext->ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Eval");
   }
 }
 
 // static
 void CXFA_FM2JSContext::is_fm_object(CFXJSE_Value* pThis,
                                      const CFX_ByteStringC& szFuncName,
                                      CFXJSE_Arguments& args) {
   if (args.GetLength() == 1) {
     std::unique_ptr<CFXJSE_Value> argOne = args.GetValue(0);
-    FXJSE_Value_SetBoolean(args.GetReturnValue(),
-                           FXJSE_Value_IsObject(argOne.get()));
+    args.GetReturnValue()->SetBoolean(FXJSE_Value_IsObject(argOne.get()));
   } else {
-    FXJSE_Value_SetBoolean(args.GetReturnValue(), FALSE);
+    args.GetReturnValue()->SetBoolean(FALSE);
   }
 }
 
 // static
 void CXFA_FM2JSContext::is_fm_array(CFXJSE_Value* pThis,
                                     const CFX_ByteStringC& szFuncName,
                                     CFXJSE_Arguments& args) {
   if (args.GetLength() == 1) {
     std::unique_ptr<CFXJSE_Value> argOne = args.GetValue(0);
     FX_BOOL bIsArray = FXJSE_Value_IsArray(argOne.get());
-    FXJSE_Value_SetBoolean(args.GetReturnValue(), bIsArray);
+    args.GetReturnValue()->SetBoolean(bIsArray);
   } else {
-    FXJSE_Value_SetBoolean(args.GetReturnValue(), FALSE);
+    args.GetReturnValue()->SetBoolean(FALSE);
   }
 }
 
 // static
 void CXFA_FM2JSContext::get_fm_value(CFXJSE_Value* pThis,
                                      const CFX_ByteStringC& szFuncName,
                                      CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = ToJSContext(pThis, nullptr);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   if (args.GetLength() == 1) {
     std::unique_ptr<CFXJSE_Value> argOne = args.GetValue(0);
     if (FXJSE_Value_IsArray(argOne.get())) {
       std::unique_ptr<CFXJSE_Value> propertyValue(new CFXJSE_Value(pIsolate));
       std::unique_ptr<CFXJSE_Value> jsObjectValue(new CFXJSE_Value(pIsolate));
-      FXJSE_Value_GetObjectPropByIdx(argOne.get(), 1, propertyValue.get());
-      FXJSE_Value_GetObjectPropByIdx(argOne.get(), 2, jsObjectValue.get());
+      argOne->GetObjectPropertyByIdx(1, propertyValue.get());
+      argOne->GetObjectPropertyByIdx(2, jsObjectValue.get());
       if (FXJSE_Value_IsNull(propertyValue.get())) {
         GetObjectDefaultValue(jsObjectValue.get(), args.GetReturnValue());
       } else {
         CFX_ByteString propertyStr;
-        FXJSE_Value_ToUTF8String(propertyValue.get(), propertyStr);
-        FXJSE_Value_GetObjectProp(jsObjectValue.get(), propertyStr.AsStringC(),
-                                  args.GetReturnValue());
+        propertyValue->ToString(propertyStr);
+        jsObjectValue->GetObjectProperty(propertyStr.AsStringC(),
+                                         args.GetReturnValue());
       }
     } else if (FXJSE_Value_IsObject(argOne.get())) {
       GetObjectDefaultValue(argOne.get(), args.GetReturnValue());
     } else {
-      FXJSE_Value_Set(args.GetReturnValue(), argOne.get());
+      args.GetReturnValue()->Assign(argOne.get());
     }
   } else {
     pContext->ThrowException(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::get_fm_jsobj(CFXJSE_Value* pThis,
                                      const CFX_ByteStringC& szFuncName,
                                      CFXJSE_Arguments& args) {
   if (args.GetLength() == 1) {
     std::unique_ptr<CFXJSE_Value> argOne = args.GetValue(0);
     if (FXJSE_Value_IsArray(argOne.get())) {
 #ifndef NDEBUG
       CXFA_FM2JSContext* pContext = ToJSContext(pThis, nullptr);
       v8::Isolate* pIsolate = pContext->GetScriptRuntime();
       std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
-      FXJSE_Value_GetObjectProp(argOne.get(), "length", lengthValue.get());
-      ASSERT(FXJSE_Value_ToInteger(lengthValue.get()) >= 3);
+      argOne->GetObjectProperty("length", lengthValue.get());
+      ASSERT(lengthValue->ToInteger() >= 3);
 #endif
-      FXJSE_Value_GetObjectPropByIdx(argOne.get(), 2, args.GetReturnValue());
+      argOne->GetObjectPropertyByIdx(2, args.GetReturnValue());
     } else {
-      FXJSE_Value_Set(args.GetReturnValue(), argOne.get());
+      args.GetReturnValue()->Assign(argOne.get());
     }
   } else {
     CXFA_FM2JSContext* pContext = ToJSContext(pThis, nullptr);
     pContext->ThrowException(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::fm_var_filter(CFXJSE_Value* pThis,
                                       const CFX_ByteStringC& szFuncName,
                                       CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = ToJSContext(pThis, nullptr);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   if (args.GetLength() == 1) {
     std::unique_ptr<CFXJSE_Value> argOne = args.GetValue(0);
     if (FXJSE_Value_IsArray(argOne.get())) {
 #ifndef NDEBUG
       std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
-      FXJSE_Value_GetObjectProp(argOne.get(), "length", lengthValue.get());
-      ASSERT(FXJSE_Value_ToInteger(lengthValue.get()) >= 3);
+      argOne->GetObjectProperty("length", lengthValue.get());
+      ASSERT(lengthValue->ToInteger() >= 3);
 #endif
       std::unique_ptr<CFXJSE_Value> flagsValue(new CFXJSE_Value(pIsolate));
-      FXJSE_Value_GetObjectPropByIdx(argOne.get(), 0, flagsValue.get());
-      int32_t iFlags = FXJSE_Value_ToInteger(flagsValue.get());
+      argOne->GetObjectPropertyByIdx(0, flagsValue.get());
+      int32_t iFlags = flagsValue->ToInteger();
       if (iFlags == 4) {
         CFXJSE_Value* rgValues[3];
         for (int32_t i = 0; i < 3; i++)
           rgValues[i] = new CFXJSE_Value(pIsolate);
 
-        FXJSE_Value_SetInteger(rgValues[0], 3);
-        FXJSE_Value_SetNull(rgValues[1]);
-        FXJSE_Value_SetNull(rgValues[2]);
-        FXJSE_Value_SetArray(args.GetReturnValue(), 3, rgValues);
+        rgValues[0]->SetInteger(3);
+        rgValues[1]->SetNull();
+        rgValues[2]->SetNull();
+        args.GetReturnValue()->SetArray(3, rgValues);
         for (int32_t i = 0; i < 3; i++)
           delete rgValues[i];
       } else if (iFlags == 3) {
         std::unique_ptr<CFXJSE_Value> objectValue(new CFXJSE_Value(pIsolate));
-        FXJSE_Value_GetObjectPropByIdx(argOne.get(), 2, objectValue.get());
+        argOne->GetObjectPropertyByIdx(2, objectValue.get());
         if (!FXJSE_Value_IsNull(objectValue.get())) {
-          FXJSE_Value_Set(args.GetReturnValue(), argOne.get());
+          args.GetReturnValue()->Assign(argOne.get());
         } else {
           pContext->ThrowException(XFA_IDS_COMPILER_ERROR);
         }
       } else {
         std::unique_ptr<CFXJSE_Value> simpleValue =
             GetSimpleValue(pThis, args, 0);
-        FXJSE_Value_Set(args.GetReturnValue(), simpleValue.get());
+        args.GetReturnValue()->Assign(simpleValue.get());
       }
     } else {
       std::unique_ptr<CFXJSE_Value> simpleValue =
           GetSimpleValue(pThis, args, 0);
-      FXJSE_Value_Set(args.GetReturnValue(), simpleValue.get());
+      args.GetReturnValue()->Assign(simpleValue.get());
     }
   } else {
     pContext->ThrowException(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::concat_fm_object(CFXJSE_Value* pThis,
                                          const CFX_ByteStringC& szFuncName,
                                          CFXJSE_Arguments& args) {
   v8::Isolate* pIsolate = ToJSContext(pThis, nullptr)->GetScriptRuntime();
   uint32_t iLength = 0;
   int32_t argc = args.GetLength();
   std::vector<std::unique_ptr<CFXJSE_Value>> argValues;
   for (int32_t i = 0; i < argc; i++) {
     argValues.push_back(args.GetValue(i));
     if (FXJSE_Value_IsArray(argValues[i].get())) {
       std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
-      FXJSE_Value_GetObjectProp(argValues[i].get(), "length",
-                                lengthValue.get());
-      int32_t length = FXJSE_Value_ToInteger(lengthValue.get());
+      argValues[i]->GetObjectProperty("length", lengthValue.get());
+      int32_t length = lengthValue->ToInteger();
       iLength = iLength + ((length > 2) ? (length - 2) : 0);
     }
     iLength += 1;
   }
   CFXJSE_Value** returnValues = FX_Alloc(CFXJSE_Value*, iLength);
   for (int32_t i = 0; i < (int32_t)iLength; i++)
     returnValues[i] = new CFXJSE_Value(pIsolate);
 
   int32_t index = 0;
   for (int32_t i = 0; i < argc; i++) {
     if (FXJSE_Value_IsArray(argValues[i].get())) {
       std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
-      FXJSE_Value_GetObjectProp(argValues[i].get(), "length",
-                                lengthValue.get());
-      int32_t length = FXJSE_Value_ToInteger(lengthValue.get());
+      argValues[i]->GetObjectProperty("length", lengthValue.get());
+      int32_t length = lengthValue->ToInteger();
       for (int32_t j = 2; j < length; j++) {
-        FXJSE_Value_GetObjectPropByIdx(argValues[i].get(), j,
-                                       returnValues[index]);
+        argValues[i]->GetObjectPropertyByIdx(j, returnValues[index]);
         index++;
       }
     }
-    FXJSE_Value_Set(returnValues[index], argValues[i].get());
+    returnValues[index]->Assign(argValues[i].get());
     index++;
   }
-  FXJSE_Value_SetArray(args.GetReturnValue(), iLength, returnValues);
+  args.GetReturnValue()->SetArray(iLength, returnValues);
   for (int32_t i = 0; i < (int32_t)iLength; i++)
     delete returnValues[i];
 
   FX_Free(returnValues);
 }
 
 // static
 std::unique_ptr<CFXJSE_Value> CXFA_FM2JSContext::GetSimpleValue(
     CFXJSE_Value* pThis,
     CFXJSE_Arguments& args,
     uint32_t index) {
   v8::Isolate* pIsolate = ToJSContext(pThis, nullptr)->GetScriptRuntime();
   ASSERT(index < (uint32_t)args.GetLength());
   std::unique_ptr<CFXJSE_Value> argIndex = args.GetValue(index);
   if (FXJSE_Value_IsArray(argIndex.get())) {
     std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
-    FXJSE_Value_GetObjectProp(argIndex.get(), "length", lengthValue.get());
-    int32_t iLength = FXJSE_Value_ToInteger(lengthValue.get());
+    argIndex->GetObjectProperty("length", lengthValue.get());
+    int32_t iLength = lengthValue->ToInteger();
     std::unique_ptr<CFXJSE_Value> simpleValue(new CFXJSE_Value(pIsolate));
     if (iLength > 2) {
       std::unique_ptr<CFXJSE_Value> propertyValue(new CFXJSE_Value(pIsolate));
       std::unique_ptr<CFXJSE_Value> jsObjectValue(new CFXJSE_Value(pIsolate));
-      FXJSE_Value_GetObjectPropByIdx(argIndex.get(), 1, propertyValue.get());
-      FXJSE_Value_GetObjectPropByIdx(argIndex.get(), 2, jsObjectValue.get());
+      argIndex->GetObjectPropertyByIdx(1, propertyValue.get());
+      argIndex->GetObjectPropertyByIdx(2, jsObjectValue.get());
       if (FXJSE_Value_IsNull(propertyValue.get())) {
         GetObjectDefaultValue(jsObjectValue.get(), simpleValue.get());
       } else {
         CFX_ByteString propertyStr;
-        FXJSE_Value_ToUTF8String(propertyValue.get(), propertyStr);
-        FXJSE_Value_GetObjectProp(jsObjectValue.get(), propertyStr.AsStringC(),
-                                  simpleValue.get());
+        propertyValue->ToString(propertyStr);
+        jsObjectValue->GetObjectProperty(propertyStr.AsStringC(),
+                                         simpleValue.get());
       }
     } else {
-      FXJSE_Value_SetUndefined(simpleValue.get());
+      simpleValue.get()->SetUndefined();
     }
     return simpleValue;
   } else if (FXJSE_Value_IsObject(argIndex.get())) {
     std::unique_ptr<CFXJSE_Value> defaultValue(new CFXJSE_Value(pIsolate));
     GetObjectDefaultValue(argIndex.get(), defaultValue.get());
     return defaultValue;
   } else {
     return argIndex;
   }
 }
 
 // static
 FX_BOOL CXFA_FM2JSContext::ValueIsNull(CFXJSE_Value* pThis, CFXJSE_Value* arg) {
   v8::Isolate* pIsolate = ToJSContext(pThis, nullptr)->GetScriptRuntime();
   FX_BOOL isNull = FALSE;
   if (FXJSE_Value_IsNull(arg)) {
     isNull = TRUE;
   } else if (FXJSE_Value_IsArray(arg)) {
     int32_t iLength = hvalue_get_array_length(pThis, arg);
     if (iLength > 2) {
       std::unique_ptr<CFXJSE_Value> propertyValue(new CFXJSE_Value(pIsolate));
       std::unique_ptr<CFXJSE_Value> jsObjectValue(new CFXJSE_Value(pIsolate));
-      FXJSE_Value_GetObjectPropByIdx(arg, 1, propertyValue.get());
-      FXJSE_Value_GetObjectPropByIdx(arg, 2, jsObjectValue.get());
+      arg->GetObjectPropertyByIdx(1, propertyValue.get());
+      arg->GetObjectPropertyByIdx(2, jsObjectValue.get());
       if (FXJSE_Value_IsNull(propertyValue.get())) {
         std::unique_ptr<CFXJSE_Value> defaultValue(new CFXJSE_Value(pIsolate));
         GetObjectDefaultValue(jsObjectValue.get(), defaultValue.get());
         if (FXJSE_Value_IsNull(defaultValue.get())) {
           isNull = TRUE;
         }
       } else {
         CFX_ByteString propertyStr;
-        FXJSE_Value_ToUTF8String(propertyValue.get(), propertyStr);
+        propertyValue->ToString(propertyStr);
         std::unique_ptr<CFXJSE_Value> newPropertyValue(
             new CFXJSE_Value(pIsolate));
-        FXJSE_Value_GetObjectProp(jsObjectValue.get(), propertyStr.AsStringC(),
-                                  newPropertyValue.get());
+        jsObjectValue->GetObjectProperty(propertyStr.AsStringC(),
+                                         newPropertyValue.get());
         if (FXJSE_Value_IsNull(newPropertyValue.get())) {
           isNull = TRUE;
         }
       }
     } else {
       isNull = TRUE;
     }
   } else if (FXJSE_Value_IsObject(arg)) {
     std::unique_ptr<CFXJSE_Value> defaultValue(new CFXJSE_Value(pIsolate));
     GetObjectDefaultValue(arg, defaultValue.get());
     if (FXJSE_Value_IsNull(defaultValue.get())) {
       isNull = TRUE;
     }
   }
   return isNull;
 }
 
 // static
 int32_t CXFA_FM2JSContext::hvalue_get_array_length(CFXJSE_Value* pThis,
                                                    CFXJSE_Value* arg) {
   v8::Isolate* pIsolate = ToJSContext(pThis, nullptr)->GetScriptRuntime();
   int32_t iLength = 0;
   if (FXJSE_Value_IsArray(arg)) {
     std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
-    FXJSE_Value_GetObjectProp(arg, "length", lengthValue.get());
-    iLength = FXJSE_Value_ToInteger(lengthValue.get());
+    arg->GetObjectProperty("length", lengthValue.get());
+    iLength = lengthValue->ToInteger();
   }
   return iLength;
 }
 
 // static
 FX_BOOL CXFA_FM2JSContext::simpleValueCompare(CFXJSE_Value* pThis,
                                               CFXJSE_Value* firstValue,
                                               CFXJSE_Value* secondValue) {
   FX_BOOL bReturn = FALSE;
   if (FXJSE_Value_IsUTF8String(firstValue)) {
     CFX_ByteString firstString, secondString;
     ValueToUTF8String(firstValue, firstString);
     ValueToUTF8String(secondValue, secondString);
     bReturn = firstString == secondString;
   } else if (FXJSE_Value_IsNumber(firstValue)) {
     FX_FLOAT first = ValueToFloat(pThis, firstValue);
     FX_FLOAT second = ValueToFloat(pThis, secondValue);
     bReturn = (first == second);
   } else if (FXJSE_Value_IsBoolean(firstValue)) {
-    bReturn = (FXJSE_Value_ToBoolean(firstValue) ==
-               FXJSE_Value_ToBoolean(secondValue));
+    bReturn = (firstValue->ToBoolean() == secondValue->ToBoolean());
   } else if (FXJSE_Value_IsNull(firstValue) &&
              FXJSE_Value_IsNull(secondValue)) {
     bReturn = TRUE;
   }
   return bReturn;
 }
 
 // static
 void CXFA_FM2JSContext::unfoldArgs(CFXJSE_Value* pThis,
                                    CFXJSE_Arguments& args,
                                    CFXJSE_Value**& resultValues,
                                    int32_t& iCount,
                                    int32_t iStart) {
   v8::Isolate* pIsolate = ToJSContext(pThis, nullptr)->GetScriptRuntime();
   iCount = 0;
   int32_t argc = args.GetLength();
   std::vector<std::unique_ptr<CFXJSE_Value>> argsValue;
   for (int32_t i = 0; i < argc - iStart; i++) {
     argsValue.push_back(args.GetValue(i + iStart));
     if (FXJSE_Value_IsArray(argsValue[i].get())) {
       std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
-      FXJSE_Value_GetObjectProp(argsValue[i].get(), "length",
-                                lengthValue.get());
-      int32_t iLength = FXJSE_Value_ToInteger(lengthValue.get());
+      argsValue[i]->GetObjectProperty("length", lengthValue.get());
+      int32_t iLength = lengthValue->ToInteger();
       iCount += ((iLength > 2) ? (iLength - 2) : 0);
     } else {
       iCount += 1;
     }
   }
   resultValues = FX_Alloc(CFXJSE_Value*, iCount);
   for (int32_t i = 0; i < iCount; i++)
     resultValues[i] = new CFXJSE_Value(pIsolate);
 
   int32_t index = 0;
   for (int32_t i = 0; i < argc - iStart; i++) {
     if (FXJSE_Value_IsArray(argsValue[i].get())) {
       std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
-      FXJSE_Value_GetObjectProp(argsValue[i].get(), "length",
-                                lengthValue.get());
-      int32_t iLength = FXJSE_Value_ToInteger(lengthValue.get());
+      argsValue[i]->GetObjectProperty("length", lengthValue.get());
+      int32_t iLength = lengthValue->ToInteger();
       if (iLength > 2) {
         std::unique_ptr<CFXJSE_Value> propertyValue(new CFXJSE_Value(pIsolate));
         std::unique_ptr<CFXJSE_Value> jsObjectValue(new CFXJSE_Value(pIsolate));
-        FXJSE_Value_GetObjectPropByIdx(argsValue[i].get(), 1,
-                                       propertyValue.get());
+        argsValue[i]->GetObjectPropertyByIdx(1, propertyValue.get());
         if (FXJSE_Value_IsNull(propertyValue.get())) {
           for (int32_t j = 2; j < iLength; j++) {
-            FXJSE_Value_GetObjectPropByIdx(argsValue[i].get(), j,
-                                           jsObjectValue.get());
+            argsValue[i]->GetObjectPropertyByIdx(j, jsObjectValue.get());
             GetObjectDefaultValue(jsObjectValue.get(), resultValues[index]);
             index++;
           }
         } else {
           CFX_ByteString propertyString;
-          FXJSE_Value_ToUTF8String(propertyValue.get(), propertyString);
+          propertyValue->ToString(propertyString);
           for (int32_t j = 2; j < iLength; j++) {
-            FXJSE_Value_GetObjectPropByIdx(argsValue[i].get(), j,
-                                           jsObjectValue.get());
-            FXJSE_Value_GetObjectProp(jsObjectValue.get(),
-                                      propertyString.AsStringC(),
-                                      resultValues[index]);
+            argsValue[i]->GetObjectPropertyByIdx(j, jsObjectValue.get());
+            jsObjectValue->GetObjectProperty(propertyString.AsStringC(),
+                                             resultValues[index]);
             index++;
           }
         }
       }
     } else if (FXJSE_Value_IsObject(argsValue[i].get())) {
       GetObjectDefaultValue(argsValue[i].get(), resultValues[index]);
       index++;
     } else {
-      FXJSE_Value_Set(resultValues[index], argsValue[i].get());
+      resultValues[index]->Assign(argsValue[i].get());
       index++;
     }
   }
 }
 
 // static
 void CXFA_FM2JSContext::GetObjectDefaultValue(CFXJSE_Value* pValue,
                                               CFXJSE_Value* pDefaultValue) {
   CXFA_Node* pNode = ToNode(CXFA_ScriptContext::ToObject(pValue, nullptr));
   if (!pNode) {
-    FXJSE_Value_SetNull(pDefaultValue);
+    pDefaultValue->SetNull();
     return;
   }
   pNode->Script_Som_DefaultValue(pDefaultValue, FALSE, (XFA_ATTRIBUTE)-1);
 }
 
 // static
 FX_BOOL CXFA_FM2JSContext::SetObjectDefaultValue(CFXJSE_Value* pValue,
                                                  CFXJSE_Value* hNewValue) {
   CXFA_Node* pNode = ToNode(CXFA_ScriptContext::ToObject(pValue, nullptr));
   if (!pNode)
@@ skipping 46 matching lines @@
   }
   CXFA_ScriptContext* pScriptContext = pDoc->GetScriptContext();
   XFA_RESOLVENODE_RS resoveNodeRS;
   uint32_t dwFlags = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Properties |
                      XFA_RESOLVENODE_Siblings | XFA_RESOLVENODE_Parent;
   int32_t iRet = pScriptContext->ResolveObjects(
       pScriptContext->GetThisObject(),
       CFX_WideString::FromUTF8(szAccessorName).AsStringC(), resoveNodeRS,
       dwFlags);
   if (iRet >= 1 && resoveNodeRS.dwFlags == XFA_RESOVENODE_RSTYPE_Nodes) {
-    FXJSE_Value_Set(accessorValue, pScriptContext->GetJSValueFromMap(
-                                       resoveNodeRS.nodes.GetAt(0)));
+    accessorValue->Assign(
+        pScriptContext->GetJSValueFromMap(resoveNodeRS.nodes.GetAt(0)));
     bFlags = TRUE;
   }
   return bFlags;
 }
 
 // static
 int32_t CXFA_FM2JSContext::ResolveObjects(CFXJSE_Value* pThis,
                                           CFXJSE_Value* pRefValue,
                                           const CFX_ByteStringC& bsSomExp,
                                           XFA_RESOLVENODE_RS& resoveNodeRS,
@@ skipping 54 matching lines @@
   CXFA_FM2JSContext* pContext = ToJSContext(pThis, nullptr);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   iSize = 0;
   resultValues = nullptr;
   if (resoveNodeRS.dwFlags == XFA_RESOVENODE_RSTYPE_Nodes) {
     bAttribute = FALSE;
     iSize = resoveNodeRS.nodes.GetSize();
     resultValues = FX_Alloc(CFXJSE_Value*, iSize);
     for (int32_t i = 0; i < iSize; i++) {
       resultValues[i] = new CFXJSE_Value(pIsolate);
-      FXJSE_Value_Set(
-          resultValues[i],
+      resultValues[i]->Assign(
           pContext->GetDocument()->GetScriptContext()->GetJSValueFromMap(
               resoveNodeRS.nodes.GetAt(i)));
     }
   } else {
     CXFA_ValueArray objectProperties(pIsolate);
     int32_t iRet = resoveNodeRS.GetAttributeResult(objectProperties);
     bAttribute = (iRet == 0);
     if (bAttribute) {
       if (FXJSE_Value_IsObject(pParentValue)) {
         iSize = 1;
         resultValues = FX_Alloc(CFXJSE_Value*, 1);
         resultValues[0] = new CFXJSE_Value(pIsolate);
-        FXJSE_Value_Set(resultValues[0], pParentValue);
+        resultValues[0]->Assign(pParentValue);
       }
     } else {
       iSize = iRet;
       resultValues = FX_Alloc(CFXJSE_Value*, iSize);
       for (int32_t i = 0; i < iSize; i++) {
         resultValues[i] = new CFXJSE_Value(pIsolate);
-        FXJSE_Value_Set(resultValues[i], objectProperties[i]);
+        resultValues[i]->Assign(objectProperties[i]);
       }
     }
   }
 }
 
 // static
 int32_t CXFA_FM2JSContext::ValueToInteger(CFXJSE_Value* pThis,
                                           CFXJSE_Value* pValue) {
   v8::Isolate* pIsolate = ToJSContext(pThis, nullptr)->GetScriptRuntime();
   int32_t iValue = 0;
   if (FXJSE_Value_IsArray(pValue)) {
     std::unique_ptr<CFXJSE_Value> propertyValue(new CFXJSE_Value(pIsolate));
     std::unique_ptr<CFXJSE_Value> jsObjectValue(new CFXJSE_Value(pIsolate));
     std::unique_ptr<CFXJSE_Value> newPropertyValue(new CFXJSE_Value(pIsolate));
-    FXJSE_Value_GetObjectPropByIdx(pValue, 1, propertyValue.get());
-    FXJSE_Value_GetObjectPropByIdx(pValue, 2, jsObjectValue.get());
+    pValue->GetObjectPropertyByIdx(1, propertyValue.get());
+    pValue->GetObjectPropertyByIdx(2, jsObjectValue.get());
     if (FXJSE_Value_IsNull(propertyValue.get())) {
       GetObjectDefaultValue(jsObjectValue.get(), newPropertyValue.get());
     } else {
       CFX_ByteString propertyStr;
-      FXJSE_Value_ToUTF8String(propertyValue.get(), propertyStr);
-      FXJSE_Value_GetObjectProp(jsObjectValue.get(), propertyStr.AsStringC(),
-                                newPropertyValue.get());
+      propertyValue->ToString(propertyStr);
+      jsObjectValue->GetObjectProperty(propertyStr.AsStringC(),
+                                       newPropertyValue.get());
     }
     iValue = ValueToInteger(pThis, newPropertyValue.get());
     return iValue;
   } else if (FXJSE_Value_IsObject(pValue)) {
     std::unique_ptr<CFXJSE_Value> newPropertyValue(new CFXJSE_Value(pIsolate));
     GetObjectDefaultValue(pValue, newPropertyValue.get());
     iValue = ValueToInteger(pThis, newPropertyValue.get());
     return iValue;
   } else if (FXJSE_Value_IsUTF8String(pValue)) {
     CFX_ByteString szValue;
-    FXJSE_Value_ToUTF8String(pValue, szValue);
+    pValue->ToString(szValue);
     iValue = FXSYS_atoi(szValue.c_str());
   } else {
-    iValue = FXJSE_Value_ToInteger(pValue);
+    iValue = pValue->ToInteger();
   }
   return iValue;
 }
 
 // static
 FX_FLOAT CXFA_FM2JSContext::ValueToFloat(CFXJSE_Value* pThis,
                                          CFXJSE_Value* arg) {
   v8::Isolate* pIsolate = ToJSContext(pThis, nullptr)->GetScriptRuntime();
   FX_FLOAT fRet = 0.0f;
   if (FXJSE_Value_IsArray(arg)) {
     std::unique_ptr<CFXJSE_Value> propertyValue(new CFXJSE_Value(pIsolate));
     std::unique_ptr<CFXJSE_Value> jsObjectValue(new CFXJSE_Value(pIsolate));
     std::unique_ptr<CFXJSE_Value> newPropertyValue(new CFXJSE_Value(pIsolate));
-    FXJSE_Value_GetObjectPropByIdx(arg, 1, propertyValue.get());
-    FXJSE_Value_GetObjectPropByIdx(arg, 2, jsObjectValue.get());
+    arg->GetObjectPropertyByIdx(1, propertyValue.get());
+    arg->GetObjectPropertyByIdx(2, jsObjectValue.get());
     if (FXJSE_Value_IsNull(propertyValue.get())) {
       GetObjectDefaultValue(jsObjectValue.get(), newPropertyValue.get());
     } else {
       CFX_ByteString propertyStr;
-      FXJSE_Value_ToUTF8String(propertyValue.get(), propertyStr);
-      FXJSE_Value_GetObjectProp(jsObjectValue.get(), propertyStr.AsStringC(),
-                                newPropertyValue.get());
+      propertyValue->ToString(propertyStr);
+      jsObjectValue->GetObjectProperty(propertyStr.AsStringC(),
+                                       newPropertyValue.get());
     }
     fRet = ValueToFloat(pThis, newPropertyValue.get());
   } else if (FXJSE_Value_IsObject(arg)) {
     std::unique_ptr<CFXJSE_Value> newPropertyValue(new CFXJSE_Value(pIsolate));
     GetObjectDefaultValue(arg, newPropertyValue.get());
     fRet = ValueToFloat(pThis, newPropertyValue.get());
   } else if (FXJSE_Value_IsUTF8String(arg)) {
     CFX_ByteString bsOutput;
-    FXJSE_Value_ToUTF8String(arg, bsOutput);
+    arg->ToString(bsOutput);
     fRet = (FX_FLOAT)XFA_ByteStringToDouble(bsOutput.AsStringC());
   } else if (FXJSE_Value_IsUndefined(arg)) {
     fRet = 0;
   } else {
-    fRet = FXJSE_Value_ToFloat(arg);
+    fRet = arg->ToFloat();
   }
   return fRet;
 }
 
 // static
 FX_DOUBLE CXFA_FM2JSContext::ValueToDouble(CFXJSE_Value* pThis,
                                            CFXJSE_Value* arg) {
   v8::Isolate* pIsolate = ToJSContext(pThis, nullptr)->GetScriptRuntime();
   FX_DOUBLE dRet = 0;
   if (FXJSE_Value_IsArray(arg)) {
     std::unique_ptr<CFXJSE_Value> propertyValue(new CFXJSE_Value(pIsolate));
     std::unique_ptr<CFXJSE_Value> jsObjectValue(new CFXJSE_Value(pIsolate));
     std::unique_ptr<CFXJSE_Value> newPropertyValue(new CFXJSE_Value(pIsolate));
-    FXJSE_Value_GetObjectPropByIdx(arg, 1, propertyValue.get());
-    FXJSE_Value_GetObjectPropByIdx(arg, 2, jsObjectValue.get());
+    arg->GetObjectPropertyByIdx(1, propertyValue.get());
+    arg->GetObjectPropertyByIdx(2, jsObjectValue.get());
     if (FXJSE_Value_IsNull(propertyValue.get())) {
       GetObjectDefaultValue(jsObjectValue.get(), newPropertyValue.get());
     } else {
       CFX_ByteString propertyStr;
-      FXJSE_Value_ToUTF8String(propertyValue.get(), propertyStr);
-      FXJSE_Value_GetObjectProp(jsObjectValue.get(), propertyStr.AsStringC(),
-                                newPropertyValue.get());
+      propertyValue->ToString(propertyStr);
+      jsObjectValue->GetObjectProperty(propertyStr.AsStringC(),
+                                       newPropertyValue.get());
     }
     dRet = ValueToDouble(pThis, newPropertyValue.get());
   } else if (FXJSE_Value_IsObject(arg)) {
     std::unique_ptr<CFXJSE_Value> newPropertyValue(new CFXJSE_Value(pIsolate));
     GetObjectDefaultValue(arg, newPropertyValue.get());
     dRet = ValueToDouble(pThis, newPropertyValue.get());
   } else if (FXJSE_Value_IsUTF8String(arg)) {
     CFX_ByteString bsOutput;
-    FXJSE_Value_ToUTF8String(arg, bsOutput);
+    arg->ToString(bsOutput);
     dRet = XFA_ByteStringToDouble(bsOutput.AsStringC());
   } else if (FXJSE_Value_IsUndefined(arg)) {
     dRet = 0;
   } else {
-    dRet = FXJSE_Value_ToDouble(arg);
+    dRet = arg->ToDouble();
   }
   return dRet;
 }
 
 // static.
 double CXFA_FM2JSContext::ExtractDouble(CFXJSE_Value* pThis,
                                         CFXJSE_Value* src,
                                         bool* ret) {
   ASSERT(ret);
 
   v8::Isolate* pIsolate = ToJSContext(pThis, nullptr)->GetScriptRuntime();
   *ret = true;
 
   if (FXJSE_Value_IsArray(src)) {
     std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
-    FXJSE_Value_GetObjectProp(src, "length", lengthValue.get());
-    int32_t iLength = FXJSE_Value_ToInteger(lengthValue.get());
+    src->GetObjectProperty("length", lengthValue.get());
+    int32_t iLength = lengthValue->ToInteger();
     if (iLength <= 2) {
       *ret = false;
       return 0.0;
     }
 
     std::unique_ptr<CFXJSE_Value> propertyValue(new CFXJSE_Value(pIsolate));
     std::unique_ptr<CFXJSE_Value> jsObjectValue(new CFXJSE_Value(pIsolate));
-    FXJSE_Value_GetObjectPropByIdx(src, 1, propertyValue.get());
-    FXJSE_Value_GetObjectPropByIdx(src, 2, jsObjectValue.get());
+    src->GetObjectPropertyByIdx(1, propertyValue.get());
+    src->GetObjectPropertyByIdx(2, jsObjectValue.get());
     if (FXJSE_Value_IsNull(propertyValue.get()))
       return ValueToDouble(pThis, jsObjectValue.get());
 
     CFX_ByteString propertyStr;
-    FXJSE_Value_ToUTF8String(propertyValue.get(), propertyStr);
+    propertyValue->ToString(propertyStr);
     std::unique_ptr<CFXJSE_Value> newPropertyValue(new CFXJSE_Value(pIsolate));
-    FXJSE_Value_GetObjectProp(jsObjectValue.get(), propertyStr.AsStringC(),
-                              newPropertyValue.get());
+    jsObjectValue->GetObjectProperty(propertyStr.AsStringC(),
+                                     newPropertyValue.get());
     return ValueToDouble(pThis, newPropertyValue.get());
   }
   return ValueToDouble(pThis, src);
 }
 
 // static
 void CXFA_FM2JSContext::ValueToUTF8String(CFXJSE_Value* arg,
                                           CFX_ByteString& szOutputString) {
   if (FXJSE_Value_IsNull(arg) || FXJSE_Value_IsUndefined(arg)) {
     szOutputString = "";
   } else if (FXJSE_Value_IsBoolean(arg)) {
-    szOutputString = FXJSE_Value_ToBoolean(arg) ? "1" : "0";
+    szOutputString = arg->ToBoolean() ? "1" : "0";
   } else {
     szOutputString = "";
-    FXJSE_Value_ToUTF8String(arg, szOutputString);
+    arg->ToString(szOutputString);
   }
 }
 
 // static.
 int32_t CXFA_FM2JSContext::Translate(const CFX_WideStringC& wsFormcalc,
                                      CFX_WideTextBuf& wsJavascript,
                                      CFX_WideString& wsError) {
   if (wsFormcalc.IsEmpty()) {
     wsJavascript.Clear();
     wsError.clear();
@@ skipping 15 matching lines @@
   return 0;
 }
 
 CXFA_FM2JSContext::CXFA_FM2JSContext(v8::Isolate* pScriptIsolate,
                                      CFXJSE_Context* pScriptContext,
                                      CXFA_Document* pDoc)
     : m_pIsolate(pScriptIsolate),
       m_pFMClass(FXJSE_DefineClass(pScriptContext, &formcalc_fm2js_descriptor)),
       m_pValue(new CFXJSE_Value(pScriptIsolate)),
       m_pDocument(pDoc) {
-  FXJSE_Value_SetNull(m_pValue.get());
-  FXJSE_Value_SetObject(m_pValue.get(), this, m_pFMClass);
+  m_pValue.get()->SetNull();
+  m_pValue.get()->SetObject(this, m_pFMClass);
 }
 
 CXFA_FM2JSContext::~CXFA_FM2JSContext() {}
 
 void CXFA_FM2JSContext::GlobalPropertyGetter(CFXJSE_Value* pValue) {
-  FXJSE_Value_Set(pValue, m_pValue.get());
+  pValue->Assign(m_pValue.get());
 }
 
 void CXFA_FM2JSContext::ThrowException(int32_t iStringID, ...) {
   IXFA_AppProvider* pAppProvider = m_pDocument->GetNotify()->GetAppProvider();
   ASSERT(pAppProvider);
   CFX_WideString wsFormat;
   pAppProvider->LoadString(iStringID, wsFormat);
   CFX_WideString wsMessage;
   va_list arg_ptr;
   va_start(arg_ptr, iStringID);
   wsMessage.FormatV(wsFormat.c_str(), arg_ptr);
   va_end(arg_ptr);
   FXJSE_ThrowMessage(
       "", FX_UTF8Encode(wsMessage.c_str(), wsMessage.GetLength()).AsStringC());
 }