Remove more FXJSE c-method wrappers.

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>
 
 #include "core/fxcrt/include/fx_ext.h"
 #include "xfa/fgas/localization/fgas_locale.h"
 #include "xfa/fxfa/app/xfa_ffnotify.h"
 #include "xfa/fxfa/fm2js/xfa_program.h"
 #include "xfa/fxfa/parser/xfa_document.h"
 #include "xfa/fxfa/parser/xfa_localevalue.h"
 #include "xfa/fxfa/parser/xfa_parser.h"
 #include "xfa/fxfa/parser/xfa_parser_imp.h"
 #include "xfa/fxfa/parser/xfa_script_imp.h"
 #include "xfa/fxjse/cfxjse_arguments.h"
+#include "xfa/fxjse/class.h"
 #include "xfa/fxjse/value.h"
 
 namespace {
 
 const double kFinancialPrecision = 0.00000001;
 
 struct XFA_FMHtmlReserveCode {
   uint32_t m_uCode;
   const FX_WCHAR* m_htmlReserve;
 };
@@ skipping 505 matching lines @@
   if (argc < 1) {
     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()))
+    if (argValue->IsNull())
       continue;
 
-    if (!FXJSE_Value_IsArray(argValue.get())) {
+    if (!argValue->IsArray()) {
       dSum += ValueToDouble(pThis, argValue.get());
       uCount++;
       continue;
     }
 
     std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
     argValue->GetObjectProperty("length", lengthValue.get());
     int32_t iLength = lengthValue->ToInteger();
 
     if (iLength > 2) {
       std::unique_ptr<CFXJSE_Value> propertyValue(new CFXJSE_Value(pIsolate));
       argValue->GetObjectPropertyByIdx(1, propertyValue.get());
 
       std::unique_ptr<CFXJSE_Value> jsObjectValue(new CFXJSE_Value(pIsolate));
-      if (FXJSE_Value_IsNull(propertyValue.get())) {
+      if (propertyValue->IsNull()) {
         for (int32_t j = 2; j < iLength; j++) {
           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()))
+          if (defaultPropValue->IsNull())
             continue;
 
           dSum += ValueToDouble(pThis, defaultPropValue.get());
           uCount++;
         }
       } else {
         CFX_ByteString propertyStr;
         propertyValue->ToString(propertyStr);
         for (int32_t j = 2; j < iLength; j++) {
           argValue->GetObjectPropertyByIdx(j, jsObjectValue.get());
           std::unique_ptr<CFXJSE_Value> newPropertyValue(
               new CFXJSE_Value(pIsolate));
           jsObjectValue->GetObjectProperty(propertyStr.AsStringC(),
                                            newPropertyValue.get());
-          if (FXJSE_Value_IsNull(newPropertyValue.get()))
+          if (newPropertyValue->IsNull())
             continue;
 
           dSum += ValueToDouble(pThis, newPropertyValue.get());
           uCount++;
         }
       }
     }
   }
   if (uCount == 0) {
     args.GetReturnValue()->SetNull();
@@ skipping 25 matching lines @@
 
 // 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()))
+    if (argValue->IsNull())
       continue;
 
-    if (FXJSE_Value_IsArray(argValue.get())) {
+    if (argValue->IsArray()) {
       std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
       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));
       argValue->GetObjectPropertyByIdx(1, propertyValue.get());
       argValue->GetObjectPropertyByIdx(2, jsObjectValue.get());
-      if (FXJSE_Value_IsNull(propertyValue.get())) {
+      if (propertyValue->IsNull()) {
         for (int32_t j = 2; j < iLength; j++) {
           argValue->GetObjectPropertyByIdx(j, jsObjectValue.get());
           GetObjectDefaultValue(jsObjectValue.get(), newPropertyValue.get());
-          if (!FXJSE_Value_IsNull(newPropertyValue.get()))
+          if (!newPropertyValue->IsNull())
             iCount++;
         }
       } else {
         CFX_ByteString propertyStr;
         propertyValue->ToString(propertyStr);
         for (int32_t j = 2; j < iLength; j++) {
           argValue->GetObjectPropertyByIdx(j, jsObjectValue.get());
           jsObjectValue->GetObjectProperty(propertyStr.AsStringC(),
                                            newPropertyValue.get());
-          iCount += (FXJSE_Value_IsNull(newPropertyValue.get()) ? 0 : 1);
+          iCount += newPropertyValue->IsNull() ? 0 : 1;
         }
       }
-    } else if (FXJSE_Value_IsObject(argValue.get())) {
+    } else if (argValue->IsObject()) {
       std::unique_ptr<CFXJSE_Value> newPropertyValue(
           new CFXJSE_Value(pIsolate));
       GetObjectDefaultValue(argValue.get(), newPropertyValue.get());
-      if (!FXJSE_Value_IsNull(newPropertyValue.get()))
+      if (!newPropertyValue->IsNull())
         iCount++;
     } else {
       iCount++;
     }
   }
   args.GetReturnValue()->SetInteger(iCount);
 }
 
 // static
 void CXFA_FM2JSContext::Floor(CFXJSE_Value* pThis,
@@ skipping 18 matching lines @@
 // 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()))
+    if (argValue->IsNull())
       continue;
 
-    if (FXJSE_Value_IsArray(argValue.get())) {
+    if (argValue->IsArray()) {
       std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
       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));
       argValue->GetObjectPropertyByIdx(1, propertyValue.get());
       argValue->GetObjectPropertyByIdx(2, jsObjectValue.get());
-      if (FXJSE_Value_IsNull(propertyValue.get())) {
+      if (propertyValue->IsNull()) {
         for (int32_t j = 2; j < iLength; j++) {
           argValue->GetObjectPropertyByIdx(j, jsObjectValue.get());
           GetObjectDefaultValue(jsObjectValue.get(), newPropertyValue.get());
-          if (FXJSE_Value_IsNull(newPropertyValue.get()))
+          if (newPropertyValue->IsNull())
             continue;
 
           uCount++;
           FX_DOUBLE dValue = ValueToDouble(pThis, newPropertyValue.get());
           dMaxValue = (uCount == 1) ? dValue : std::max(dMaxValue, dValue);
         }
       } else {
         CFX_ByteString propertyStr;
         propertyValue->ToString(propertyStr);
         for (int32_t j = 2; j < iLength; j++) {
           argValue->GetObjectPropertyByIdx(j, jsObjectValue.get());
           jsObjectValue->GetObjectProperty(propertyStr.AsStringC(),
                                            newPropertyValue.get());
-          if (FXJSE_Value_IsNull(newPropertyValue.get()))
+          if (newPropertyValue->IsNull())
             continue;
 
           uCount++;
           FX_DOUBLE dValue = ValueToDouble(pThis, newPropertyValue.get());
           dMaxValue = (uCount == 1) ? dValue : std::max(dMaxValue, dValue);
         }
       }
-    } else if (FXJSE_Value_IsObject(argValue.get())) {
+    } else if (argValue->IsObject()) {
       std::unique_ptr<CFXJSE_Value> newPropertyValue(
           new CFXJSE_Value(pIsolate));
       GetObjectDefaultValue(argValue.get(), newPropertyValue.get());
-      if (FXJSE_Value_IsNull(newPropertyValue.get()))
+      if (newPropertyValue->IsNull())
         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) {
     args.GetReturnValue()->SetNull();
     return;
   }
 
   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()))
+    if (argValue->IsNull())
       continue;
 
-    if (FXJSE_Value_IsArray(argValue.get())) {
+    if (argValue->IsArray()) {
       std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
       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));
       argValue->GetObjectPropertyByIdx(1, propertyValue.get());
       argValue->GetObjectPropertyByIdx(2, jsObjectValue.get());
-      if (FXJSE_Value_IsNull(propertyValue.get())) {
+      if (propertyValue->IsNull()) {
         for (int32_t j = 2; j < iLength; j++) {
           argValue->GetObjectPropertyByIdx(j, jsObjectValue.get());
           GetObjectDefaultValue(jsObjectValue.get(), newPropertyValue.get());
-          if (FXJSE_Value_IsNull(newPropertyValue.get()))
+          if (newPropertyValue->IsNull())
             continue;
 
           uCount++;
           FX_DOUBLE dValue = ValueToDouble(pThis, newPropertyValue.get());
           dMinValue = uCount == 1 ? dValue : std::min(dMinValue, dValue);
         }
       } else {
         CFX_ByteString propertyStr;
         propertyValue->ToString(propertyStr);
         for (int32_t j = 2; j < iLength; j++) {
           argValue->GetObjectPropertyByIdx(j, jsObjectValue.get());
           jsObjectValue->GetObjectProperty(propertyStr.AsStringC(),
                                            newPropertyValue.get());
-          if (FXJSE_Value_IsNull(newPropertyValue.get()))
+          if (newPropertyValue->IsNull())
             continue;
 
           uCount++;
           FX_DOUBLE dValue = ValueToDouble(pThis, newPropertyValue.get());
           dMinValue = uCount == 1 ? dValue : std::min(dMinValue, dValue);
         }
       }
-    } else if (FXJSE_Value_IsObject(argValue.get())) {
+    } else if (argValue->IsObject()) {
       std::unique_ptr<CFXJSE_Value> newPropertyValue(
           new CFXJSE_Value(pIsolate));
       GetObjectDefaultValue(argValue.get(), newPropertyValue.get());
-      if (FXJSE_Value_IsNull(newPropertyValue.get()))
+      if (newPropertyValue->IsNull())
         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);
     }
@@ skipping 11 matching lines @@
                             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())) {
+  if (argOne->IsNull() || argTwo->IsNull()) {
     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);
@@ skipping 14 matching lines @@
                               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())) {
+  if (argOne->IsNull()) {
     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())) {
+    if (argTwo->IsNull()) {
       args.GetReturnValue()->SetNull();
       return;
     }
 
     bool dPrecisionRet;
     FX_DOUBLE dPrecision = ExtractDouble(pThis, argTwo.get(), &dPrecisionRet);
     if (!dPrecisionRet) {
       pContext->ThrowException(XFA_IDS_ARGUMENT_MISMATCH);
       return;
     }
@@ skipping 16 matching lines @@
     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()))
+    if (argValue->IsNull())
       continue;
 
-    if (FXJSE_Value_IsArray(argValue.get())) {
+    if (argValue->IsArray()) {
       std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
       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));
       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())) {
+      if (propertyValue->IsNull()) {
         for (int32_t j = 2; j < iLength; j++) {
           argValue->GetObjectPropertyByIdx(j, jsObjectValue.get());
           GetObjectDefaultValue(jsObjectValue.get(), newPropertyValue.get());
-          if (FXJSE_Value_IsNull(newPropertyValue.get()))
+          if (newPropertyValue->IsNull())
             continue;
 
           dSum += ValueToDouble(pThis, jsObjectValue.get());
           uCount++;
         }
       } else {
         CFX_ByteString propertyStr;
         propertyValue->ToString(propertyStr);
         for (int32_t j = 2; j < iLength; j++) {
           argValue->GetObjectPropertyByIdx(j, jsObjectValue.get());
           jsObjectValue->GetObjectProperty(propertyStr.AsStringC(),
                                            newPropertyValue.get());
-          if (FXJSE_Value_IsNull(newPropertyValue.get()))
+          if (newPropertyValue->IsNull())
             continue;
 
           dSum += ValueToDouble(pThis, newPropertyValue.get());
           uCount++;
         }
       }
-    } else if (FXJSE_Value_IsObject(argValue.get())) {
+    } else if (argValue->IsObject()) {
       std::unique_ptr<CFXJSE_Value> newPropertyValue(
           new CFXJSE_Value(pIsolate));
       GetObjectDefaultValue(argValue.get(), newPropertyValue.get());
-      if (FXJSE_Value_IsNull(newPropertyValue.get()))
+      if (newPropertyValue->IsNull())
         continue;
 
       dSum += ValueToDouble(pThis, argValue.get());
       uCount++;
     } else {
       dSum += ValueToDouble(pThis, argValue.get());
       uCount++;
     }
   }
   if (uCount == 0) {
@@ skipping 87 matching lines @@
   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())) {
+    if (argStyle->IsNull()) {
       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())) {
+    if (argLocal->IsNull()) {
       args.GetReturnValue()->SetNull();
       return;
     }
     ValueToUTF8String(argLocal.get(), szLocal);
   }
 
   CFX_ByteString formatStr;
   GetStandardDateFormat(pThis, iStyle, szLocal.AsStringC(), formatStr);
   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())) {
+  if (argOne->IsNull()) {
     args.GetReturnValue()->SetNull();
     return;
   }
 
   CFX_ByteString szArgString;
   ValueToUTF8String(argOne.get(), szArgString);
   args.GetReturnValue()->SetInteger(DateString2Num(szArgString.AsStringC()));
 }
 
 // static
@@ skipping 62 matching lines @@
   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())) {
+    if (argStyle->IsNull()) {
       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())) {
+    if (argLocal->IsNull()) {
       args.GetReturnValue()->SetNull();
       return;
     }
     ValueToUTF8String(argLocal.get(), szLocal);
   }
 
   CFX_ByteString formatStr;
   GetLocalDateFormat(pThis, iStyle, szLocal.AsStringC(), formatStr, FALSE);
   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())) {
+    if (argStyle->IsNull()) {
       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())) {
+    if (argLocal->IsNull()) {
       args.GetReturnValue()->SetNull();
       return;
     }
     ValueToUTF8String(argLocal.get(), szLocal);
   }
 
   CFX_ByteString formatStr;
   GetLocalTimeFormat(pThis, iStyle, szLocal.AsStringC(), formatStr, FALSE);
   args.GetReturnValue()->SetString(formatStr.AsStringC());
 }
@@ skipping 145 matching lines @@
                                    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())) {
+  if (timeValue->IsNull()) {
     args.GetReturnValue()->SetNull();
     return;
   }
   int32_t iTime = (int32_t)ValueToFloat(pThis, timeValue.get());
   if (FXSYS_abs(iTime) < 1.0) {
     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())) {
+    if (formatValue->IsNull()) {
       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())) {
+    if (localValue->IsNull()) {
       args.GetReturnValue()->SetNull();
       return;
     }
     ValueToUTF8String(localValue.get(), localString);
   }
 
   CFX_ByteString szGMTTimeString;
   Num2AllTime(pThis, iTime, formatString.AsStringC(), localString.AsStringC(),
               TRUE, szGMTTimeString);
   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())) {
+  if (timeValue->IsNull()) {
     args.GetReturnValue()->SetNull();
     return;
   }
   FX_FLOAT fTime = ValueToFloat(pThis, timeValue.get());
   if (FXSYS_fabs(fTime) < 1.0) {
     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())) {
+    if (formatValue->IsNull()) {
       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())) {
+    if (localValue->IsNull()) {
       args.GetReturnValue()->SetNull();
       return;
     }
     ValueToUTF8String(localValue.get(), localString);
   }
 
   CFX_ByteString szLocalTimeString;
   Num2AllTime(pThis, (int32_t)fTime, formatString.AsStringC(),
               localString.AsStringC(), FALSE, szLocalTimeString);
   args.GetReturnValue()->SetString(szLocalTimeString.AsStringC());
@@ skipping 116 matching lines @@
   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())) {
+    if (argStyle->IsNull()) {
       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())) {
+    if (argLocal->IsNull()) {
       args.GetReturnValue()->SetNull();
       return;
     }
     ValueToUTF8String(argLocal.get(), szLocal);
   }
 
   CFX_ByteString formatStr;
   GetStandardTimeFormat(pThis, iStyle, szLocal.AsStringC(), formatStr);
   args.GetReturnValue()->SetString(formatStr.AsStringC());
 }
@@ skipping 1137 matching lines @@
     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())) {
+    if (argIndexValue->IsArray()) {
       std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
       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));
         argIndexValue->GetObjectPropertyByIdx(1, propertyValue.get());
         argIndexValue->GetObjectPropertyByIdx(
             (iLength - 1) - (iValueIndex - iIndex), jsObjectValue.get());
-        if (FXJSE_Value_IsNull(propertyValue.get())) {
+        if (propertyValue->IsNull()) {
           GetObjectDefaultValue(jsObjectValue.get(), newPropertyValue.get());
         } else {
           CFX_ByteString propStr;
           propertyValue->ToString(propStr);
           jsObjectValue->GetObjectProperty(propStr.AsStringC(),
                                            newPropertyValue.get());
         }
         CFX_ByteString bsChoosed;
         ValueToUTF8String(newPropertyValue.get(), bsChoosed);
         args.GetReturnValue()->SetString(bsChoosed.AsStringC());
@@ skipping 16 matching lines @@
 
 // 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;
   }
-
-  args.GetReturnValue()->SetInteger(
-      FXJSE_Value_IsObject(args.GetValue(0).get()));
+  args.GetReturnValue()->SetInteger(args.GetValue(0)->IsObject());
 }
 
 // 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())) {
-    args.GetReturnValue()->SetInteger(FXJSE_Value_IsNumber(argOne.get()) ||
-                                      FXJSE_Value_IsBoolean(argOne.get()));
+  if (!argOne->IsString()) {
+    args.GetReturnValue()->SetInteger(argOne->IsNumber() ||
+                                      argOne->IsBoolean());
     return;
   }
 
   CFX_ByteString valueStr;
   argOne->ToString(valueStr);
   valueStr.TrimLeft();
   args.GetReturnValue()->SetInteger(!valueStr.IsEmpty());
 }
 
 // static
@@ skipping 28 matching lines @@
 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())) {
+  if (argOne->IsNull()) {
     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())) {
+  if (argOne->IsNumber()) {
     FX_FLOAT oneNumber = ValueToFloat(pThis, argOne.get());
     FX_FLOAT lowNumber = ValueToFloat(pThis, argLow.get());
     FX_FLOAT heightNumber = ValueToFloat(pThis, argHigh.get());
     args.GetReturnValue()->SetInteger((oneNumber >= lowNumber) &&
                                       (oneNumber <= heightNumber));
     return;
   }
 
   CFX_ByteString oneString;
   CFX_ByteString lowString;
@@ skipping 38 matching lines @@
   if (utf8ScriptString.IsEmpty()) {
     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_Context> pNewContext(
+      CFXJSE_Context::Create(pIsolate, nullptr, nullptr));
 
   std::unique_ptr<CFXJSE_Value> returnValue(new CFXJSE_Value(pIsolate));
   CFX_WideString javaScript(wsJavaScriptBuf.AsStringC());
-  FXJSE_ExecuteScript(
-      pNewContext,
+  pNewContext->ExecuteScript(
       FX_UTF8Encode(javaScript.c_str(), javaScript.GetLength()).c_str(),
       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())) {
+  if (!argOne->IsArray() && !argOne->IsObject() && !argOne->IsBoolean() &&
+      !argOne->IsString() && !argOne->IsNull() && !argOne->IsNumber()) {
     pContext->ThrowException(XFA_IDS_ARGUMENT_MISMATCH);
     return;
   }
 
-  if (FXJSE_Value_IsBoolean(argOne.get()) ||
-      FXJSE_Value_IsUTF8String(argOne.get()) ||
-      FXJSE_Value_IsNumber(argOne.get())) {
+  if (argOne->IsBoolean() || argOne->IsString() || argOne->IsNumber()) {
     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())) {
+  if (argOne->IsNull()) {
+    // TODO(dsinclair): Why is this 4 when the others are all 3?
     intVal = 4;
     rgValues[2]->SetNull();
-  } else if (FXJSE_Value_IsArray(argOne.get())) {
+  } else if (argOne->IsArray()) {
 #ifndef NDEBUG
     std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
     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));
     argOne->GetObjectPropertyByIdx(1, propertyValue.get());
     argOne->GetObjectPropertyByIdx(2, jsObjectValue.get());
-    if (!FXJSE_Value_IsNull(propertyValue.get()) ||
-        FXJSE_Value_IsNull(jsObjectValue.get())) {
+    if (!propertyValue->IsNull() || jsObjectValue->IsNull()) {
       for (int32_t i = 0; i < 3; i++)
         delete rgValues[i];
 
       pContext->ThrowException(XFA_IDS_ARGUMENT_MISMATCH);
       return;
     }
 
     rgValues[2]->Assign(jsObjectValue.get());
-  } else if (FXJSE_Value_IsObject(argOne.get())) {
+  } else if (argOne->IsObject()) {
     rgValues[2]->Assign(argOne.get());
   }
 
   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())) {
+  if (unitspanValue->IsNull()) {
     args.GetReturnValue()->SetNull();
     return;
   }
 
   CFX_ByteString unitspanString;
   ValueToUTF8String(unitspanValue.get(), unitspanString);
   if (unitspanString.IsEmpty()) {
     args.GetReturnValue()->SetString("in");
     return;
   }
@@ skipping 93 matching lines @@
                                   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())) {
+  if (unitspanValue->IsNull()) {
     args.GetReturnValue()->SetNull();
     return;
   }
 
   CFX_ByteString unitspanString;
   ValueToUTF8String(unitspanValue.get(), unitspanString);
   const FX_CHAR* pData = unitspanString.c_str();
   if (!pData) {
     args.GetReturnValue()->SetInteger(0);
     return;
@@ skipping 1222 matching lines @@
         ->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())) {
+    if (argOne->IsNull()) {
       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++;
@@ skipping 11 matching lines @@
 void CXFA_FM2JSContext::Str(CFXJSE_Value* pThis,
                             const CFX_ByteStringC& szFuncName,
                             CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if ((argc > 0) && (argc < 4)) {
     FX_BOOL bFlags = FALSE;
     FX_FLOAT fNumber = 0.0f;
     int32_t iWidth = 10;
     int32_t iPrecision = 0;
     std::unique_ptr<CFXJSE_Value> numberValue = GetSimpleValue(pThis, args, 0);
-    if (FXJSE_Value_IsNull(numberValue.get())) {
+    if (numberValue->IsNull()) {
       bFlags = TRUE;
     } else {
       fNumber = ValueToFloat(pThis, numberValue.get());
     }
     if (argc > 1) {
       std::unique_ptr<CFXJSE_Value> widthValue = GetSimpleValue(pThis, args, 1);
       iWidth = (int32_t)ValueToFloat(pThis, widthValue.get());
     }
     if (argc > 2) {
       std::unique_ptr<CFXJSE_Value> precisionValue =
@@ skipping 100 matching lines @@
   int32_t argc = args.GetLength();
   if ((argc == 3) || (argc == 4)) {
     CFX_ByteString sourceString;
     CFX_ByteString insertString;
     int32_t iLength = 0;
     int32_t iStart = 0;
     int32_t iDelete = 0;
     std::unique_ptr<CFXJSE_Value> sourceValue = GetSimpleValue(pThis, args, 0);
     std::unique_ptr<CFXJSE_Value> startValue = GetSimpleValue(pThis, args, 1);
     std::unique_ptr<CFXJSE_Value> deleteValue = GetSimpleValue(pThis, args, 2);
-    if (!FXJSE_Value_IsNull(sourceValue.get()) &&
-        !FXJSE_Value_IsNull(startValue.get()) &&
-        !FXJSE_Value_IsNull(deleteValue.get())) {
+    if (!sourceValue->IsNull() && !startValue->IsNull() &&
+        !deleteValue->IsNull()) {
       ValueToUTF8String(sourceValue.get(), sourceString);
       iLength = sourceString.GetLength();
       iStart = (int32_t)ValueToFloat(pThis, startValue.get());
       if (iStart < 1) {
         iStart = 1;
       }
       if (iStart > iLength) {
         iStart = iLength;
       }
       iDelete = (int32_t)ValueToFloat(pThis, deleteValue.get());
@@ skipping 138 matching lines @@
 void CXFA_FM2JSContext::WordNum(CFXJSE_Value* pThis,
                                 const CFX_ByteStringC& szFuncName,
                                 CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if ((argc > 0) && (argc < 4)) {
     FX_BOOL bFlags = FALSE;
     FX_FLOAT fNumber = 0.0f;
     int32_t iIdentifier = 0;
     CFX_ByteString localeString;
     std::unique_ptr<CFXJSE_Value> numberValue = GetSimpleValue(pThis, args, 0);
-    if (FXJSE_Value_IsNull(numberValue.get())) {
+    if (numberValue->IsNull()) {
       bFlags = TRUE;
     } else {
       fNumber = ValueToFloat(pThis, numberValue.get());
     }
     if (argc > 1) {
       std::unique_ptr<CFXJSE_Value> identifierValue =
           GetSimpleValue(pThis, args, 1);
-      if (FXJSE_Value_IsNull(identifierValue.get())) {
+      if (identifierValue->IsNull()) {
         bFlags = TRUE;
       } else {
         iIdentifier = (int32_t)ValueToFloat(pThis, identifierValue.get());
       }
     }
     if (argc > 2) {
       std::unique_ptr<CFXJSE_Value> localeValue =
           GetSimpleValue(pThis, args, 2);
-      if (FXJSE_Value_IsNull(localeValue.get())) {
+      if (localeValue->IsNull()) {
         bFlags = TRUE;
       } else {
         ValueToUTF8String(localeValue.get(), localeString);
       }
     }
     if (!bFlags) {
       if ((fNumber < 0) || (fNumber > 922337203685477550)) {
         args.GetReturnValue()->SetString("*");
       } else {
         CFX_ByteTextBuf resultBuf;
@@ skipping 341 matching lines @@
 // 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())) {
+    if (lValue->IsArray()) {
       std::unique_ptr<CFXJSE_Value> leftLengthValue(new CFXJSE_Value(pIsolate));
       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));
       lValue->GetObjectPropertyByIdx(1, propertyValue.get());
-      if (FXJSE_Value_IsNull(propertyValue.get())) {
+      if (propertyValue->IsNull()) {
         for (int32_t i = 2; i < iLeftLength; i++) {
           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;
         propertyValue->ToString(propertyStr);
         for (int32_t i = 2; i < iLeftLength; i++) {
           lValue->GetObjectPropertyByIdx(i, jsObjectValue.get());
           jsObjectValue->SetObjectProperty(propertyStr.AsStringC(),
                                            rValue.get());
         }
       }
-    } else if (FXJSE_Value_IsObject(lValue.get())) {
+    } else if (lValue->IsObject()) {
       bSetStatus = SetObjectDefaultValue(lValue.get(), rValue.get());
       if (!bSetStatus) {
         pContext->ThrowException(XFA_IDS_NOT_DEFAUL_VALUE);
       }
     }
     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())) {
+    if (argFirst->IsNull() && argSecond->IsNull()) {
       args.GetReturnValue()->SetNull();
     } else {
       FX_FLOAT first = ValueToFloat(pThis, argFirst.get());
       FX_FLOAT second = ValueToFloat(pThis, argSecond.get());
       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())) {
+    if (argFirst->IsNull() && argSecond->IsNull()) {
       args.GetReturnValue()->SetNull();
     } else {
       FX_FLOAT first = ValueToFloat(pThis, argFirst.get());
       FX_FLOAT second = ValueToFloat(pThis, argSecond.get());
       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)) {
       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())) {
-        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())) {
+      if (argFirst->IsNull() || argSecond->IsNull()) {
+        args.GetReturnValue()->SetInteger(
+            (argFirst->IsNull() && argSecond->IsNull()) ? 1 : 0);
+      } else if (argFirst->IsString() && argSecond->IsString()) {
         CFX_ByteString firstOutput;
         CFX_ByteString 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());
         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)) {
       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())) {
-        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())) {
+      if (argFirst->IsNull() || argSecond->IsNull()) {
+        args.GetReturnValue()->SetInteger(
+            (argFirst->IsNull() && argSecond->IsNull()) ? 0 : 1);
+      } else if (argFirst->IsString() && argSecond->IsString()) {
         CFX_ByteString firstOutput;
         CFX_ByteString 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());
         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())) {
+  if (argFirst->IsArray() && argSecond->IsArray()) {
     std::unique_ptr<CFXJSE_Value> firstFlagValue(new CFXJSE_Value(pIsolate));
     std::unique_ptr<CFXJSE_Value> secondFlagValue(new CFXJSE_Value(pIsolate));
     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));
       argFirst->GetObjectPropertyByIdx(2, firstJSObject.get());
       argSecond->GetObjectPropertyByIdx(2, secondJSObject.get());
-      if (!FXJSE_Value_IsNull(firstJSObject.get()) &&
-          !FXJSE_Value_IsNull(secondJSObject.get())) {
+      if (!firstJSObject->IsNull() && !secondJSObject->IsNull()) {
         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())) {
+    if (argFirst->IsNull() || argSecond->IsNull()) {
       args.GetReturnValue()->SetInteger(0);
-    } else if (FXJSE_Value_IsUTF8String(argFirst.get()) &&
-               FXJSE_Value_IsUTF8String(argSecond.get())) {
+    } else if (argFirst->IsString() && argSecond->IsString()) {
       CFX_ByteString firstOutput;
       CFX_ByteString secondOutput;
       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());
       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())) {
-      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())) {
+    if (argFirst->IsNull() || argSecond->IsNull()) {
+      args.GetReturnValue()->SetInteger(
+          (argFirst->IsNull() && argSecond->IsNull()) ? 1 : 0);
+    } else if (argFirst->IsString() && argSecond->IsString()) {
       CFX_ByteString firstOutput;
       CFX_ByteString secondOutput;
       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());
       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())) {
+    if (argFirst->IsNull() || argSecond->IsNull()) {
       args.GetReturnValue()->SetInteger(0);
-    } else if (FXJSE_Value_IsUTF8String(argFirst.get()) &&
-               FXJSE_Value_IsUTF8String(argSecond.get())) {
+    } else if (argFirst->IsString() && argSecond->IsString()) {
       CFX_ByteString firstOutput;
       CFX_ByteString secondOutput;
       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());
       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())) {
-      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())) {
+    if (argFirst->IsNull() || argSecond->IsNull()) {
+      args.GetReturnValue()->SetInteger(
+          (argFirst->IsNull() && argSecond->IsNull()) ? 1 : 0);
+    } else if (argFirst->IsString() && argSecond->IsString()) {
       CFX_ByteString firstOutput;
       CFX_ByteString secondOutput;
       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());
       args.GetReturnValue()->SetInteger((first >= second) ? 1 : 0);
@@ skipping 23 matching lines @@
   }
 }
 
 // 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())) {
+    if (argFirst->IsNull() && argSecond->IsNull()) {
       args.GetReturnValue()->SetNull();
     } else {
       FX_DOUBLE first = ValueToDouble(pThis, argFirst.get());
       FX_DOUBLE second = ValueToDouble(pThis, argSecond.get());
       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())) {
+    if (argFirst->IsNull() && argSecond->IsNull()) {
       args.GetReturnValue()->SetNull();
     } else {
       FX_DOUBLE first = ValueToDouble(pThis, argFirst.get());
       FX_DOUBLE second = ValueToDouble(pThis, argSecond.get());
       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())) {
+    if (argFirst->IsNull() && argSecond->IsNull()) {
       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 {
         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())) {
+    if (argOne->IsNull()) {
       args.GetReturnValue()->SetNull();
     } else {
       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())) {
+    if (argOne->IsNull()) {
       args.GetReturnValue()->SetNull();
     } else {
       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())) {
+    if (argOne->IsNull()) {
       args.GetReturnValue()->SetNull();
     } else {
       FX_DOUBLE first = ValueToDouble(pThis, argOne.get());
       args.GetReturnValue()->SetInteger((first == 0.0) ? 1 : 0);
     }
   } else {
     ToJSContext(pThis, nullptr)->ThrowException(XFA_IDS_COMPILER_ERROR);
   }
 }
 
@@ skipping 12 matching lines @@
     int32_t iIndexFlags = args.GetInt32(3);
     int32_t iIndexValue = 0;
     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())) {
+    if (argAccessor->IsArray()) {
       std::unique_ptr<CFXJSE_Value> pLengthValue(new CFXJSE_Value(pIsolate));
       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));
@@ skipping 48 matching lines @@
 
         if (iSizes[i] > 0) {
           FX_Free(hResolveValues[i]);
         }
       }
       FX_Free(hResolveValues);
       FX_Free(iSizes);
     } else {
       XFA_RESOLVENODE_RS resoveNodeRS;
       int32_t iRet = 0;
-      if (FXJSE_Value_IsObject(argAccessor.get()) ||
-          (FXJSE_Value_IsNull(argAccessor.get()) && bsAccessorName.IsEmpty())) {
+      if (argAccessor->IsObject() ||
+          (argAccessor->IsNull() && bsAccessorName.IsEmpty())) {
         iRet = ResolveObjects(pThis, argAccessor.get(), szSomExp.AsStringC(),
                               resoveNodeRS, TRUE, szName.IsEmpty());
-      } else if (!FXJSE_Value_IsObject(argAccessor.get()) &&
-                 !bsAccessorName.IsEmpty()) {
+      } else if (!argAccessor->IsObject() && !bsAccessorName.IsEmpty()) {
         FX_BOOL bGetObject = GetObjectByName(pThis, argAccessor.get(),
                                              bsAccessorName.AsStringC());
         if (bGetObject) {
           iRet = ResolveObjects(pThis, argAccessor.get(), szSomExp.AsStringC(),
                                 resoveNodeRS, TRUE, szName.IsEmpty());
         }
       }
       if (iRet > 0) {
         CFXJSE_Value** hResolveValues;
         int32_t iSize = 0;
@@ skipping 52 matching lines @@
     int32_t iIndexFlags = args.GetInt32(3);
     int32_t iIndexValue = 0;
     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())) {
+    if (argAccessor->IsArray()) {
       std::unique_ptr<CFXJSE_Value> pLengthValue(new CFXJSE_Value(pIsolate));
       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++) {
         argAccessor->GetObjectPropertyByIdx(i, hJSObjValue.get());
@@ skipping 43 matching lines @@
         for (int32_t j = 0; j < iSizes[i]; j++)
           delete hResolveValues[i][j];
 
         FX_Free(hResolveValues[i]);
       }
       FX_Free(hResolveValues);
       FX_Free(iSizes);
     } else {
       XFA_RESOLVENODE_RS resoveNodeRS;
       int32_t iRet = 0;
-      if (FXJSE_Value_IsObject(argAccessor.get()) ||
-          (FXJSE_Value_IsNull(argAccessor.get()) && bsAccessorName.IsEmpty())) {
+      if (argAccessor->IsObject() ||
+          (argAccessor->IsNull() && bsAccessorName.IsEmpty())) {
         iRet = ResolveObjects(pThis, argAccessor.get(), szSomExp.AsStringC(),
                               resoveNodeRS, FALSE);
-      } else if (!FXJSE_Value_IsObject(argAccessor.get()) &&
-                 !bsAccessorName.IsEmpty()) {
+      } else if (!argAccessor->IsObject() && !bsAccessorName.IsEmpty()) {
         FX_BOOL bGetObject = GetObjectByName(pThis, argAccessor.get(),
                                              bsAccessorName.AsStringC());
         if (bGetObject) {
           iRet = ResolveObjects(pThis, argAccessor.get(), szSomExp.AsStringC(),
                                 resoveNodeRS, FALSE);
         }
       }
       if (iRet > 0) {
         CFXJSE_Value** hResolveValues;
         int32_t iSize = 0;
@@ skipping 68 matching lines @@
     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);
-    args.GetReturnValue()->SetBoolean(FXJSE_Value_IsObject(argOne.get()));
+    args.GetReturnValue()->SetBoolean(argOne->IsObject());
   } else {
     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());
-    args.GetReturnValue()->SetBoolean(bIsArray);
+    args.GetReturnValue()->SetBoolean(argOne->IsArray());
   } else {
     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())) {
+    if (argOne->IsArray()) {
       std::unique_ptr<CFXJSE_Value> propertyValue(new CFXJSE_Value(pIsolate));
       std::unique_ptr<CFXJSE_Value> jsObjectValue(new CFXJSE_Value(pIsolate));
       argOne->GetObjectPropertyByIdx(1, propertyValue.get());
       argOne->GetObjectPropertyByIdx(2, jsObjectValue.get());
-      if (FXJSE_Value_IsNull(propertyValue.get())) {
+      if (propertyValue->IsNull()) {
         GetObjectDefaultValue(jsObjectValue.get(), args.GetReturnValue());
       } else {
         CFX_ByteString propertyStr;
         propertyValue->ToString(propertyStr);
         jsObjectValue->GetObjectProperty(propertyStr.AsStringC(),
                                          args.GetReturnValue());
       }
-    } else if (FXJSE_Value_IsObject(argOne.get())) {
+    } else if (argOne->IsObject()) {
       GetObjectDefaultValue(argOne.get(), args.GetReturnValue());
     } else {
       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())) {
+    if (argOne->IsArray()) {
 #ifndef NDEBUG
       CXFA_FM2JSContext* pContext = ToJSContext(pThis, nullptr);
       v8::Isolate* pIsolate = pContext->GetScriptRuntime();
       std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
       argOne->GetObjectProperty("length", lengthValue.get());
       ASSERT(lengthValue->ToInteger() >= 3);
 #endif
       argOne->GetObjectPropertyByIdx(2, args.GetReturnValue());
     } else {
       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())) {
+    if (argOne->IsArray()) {
 #ifndef NDEBUG
       std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
       argOne->GetObjectProperty("length", lengthValue.get());
       ASSERT(lengthValue->ToInteger() >= 3);
 #endif
       std::unique_ptr<CFXJSE_Value> flagsValue(new CFXJSE_Value(pIsolate));
       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);
 
         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));
         argOne->GetObjectPropertyByIdx(2, objectValue.get());
-        if (!FXJSE_Value_IsNull(objectValue.get())) {
+        if (!objectValue->IsNull()) {
           args.GetReturnValue()->Assign(argOne.get());
         } else {
           pContext->ThrowException(XFA_IDS_COMPILER_ERROR);
         }
       } else {
         std::unique_ptr<CFXJSE_Value> simpleValue =
             GetSimpleValue(pThis, args, 0);
         args.GetReturnValue()->Assign(simpleValue.get());
       }
     } else {
       std::unique_ptr<CFXJSE_Value> simpleValue =
           GetSimpleValue(pThis, args, 0);
       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())) {
+    if (argValues[i]->IsArray()) {
       std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
       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())) {
+    if (argValues[i]->IsArray()) {
       std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
       argValues[i]->GetObjectProperty("length", lengthValue.get());
       int32_t length = lengthValue->ToInteger();
       for (int32_t j = 2; j < length; j++) {
         argValues[i]->GetObjectPropertyByIdx(j, returnValues[index]);
         index++;
       }
     }
     returnValues[index]->Assign(argValues[i].get());
     index++;
   }
   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())) {
+  if (argIndex->IsArray()) {
     std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
     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));
       argIndex->GetObjectPropertyByIdx(1, propertyValue.get());
       argIndex->GetObjectPropertyByIdx(2, jsObjectValue.get());
-      if (FXJSE_Value_IsNull(propertyValue.get())) {
+      if (propertyValue->IsNull()) {
         GetObjectDefaultValue(jsObjectValue.get(), simpleValue.get());
       } else {
         CFX_ByteString propertyStr;
         propertyValue->ToString(propertyStr);
         jsObjectValue->GetObjectProperty(propertyStr.AsStringC(),
                                          simpleValue.get());
       }
     } else {
       simpleValue.get()->SetUndefined();
     }
     return simpleValue;
-  } else if (FXJSE_Value_IsObject(argIndex.get())) {
+  } else if (argIndex->IsObject()) {
     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)) {
+  if (!arg || arg->IsNull()) {
     isNull = TRUE;
-  } else if (FXJSE_Value_IsArray(arg)) {
+  } else if (arg->IsArray()) {
     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));
       arg->GetObjectPropertyByIdx(1, propertyValue.get());
       arg->GetObjectPropertyByIdx(2, jsObjectValue.get());
-      if (FXJSE_Value_IsNull(propertyValue.get())) {
+      if (propertyValue->IsNull()) {
         std::unique_ptr<CFXJSE_Value> defaultValue(new CFXJSE_Value(pIsolate));
         GetObjectDefaultValue(jsObjectValue.get(), defaultValue.get());
-        if (FXJSE_Value_IsNull(defaultValue.get())) {
+        if (defaultValue->IsNull()) {
           isNull = TRUE;
         }
       } else {
         CFX_ByteString propertyStr;
         propertyValue->ToString(propertyStr);
         std::unique_ptr<CFXJSE_Value> newPropertyValue(
             new CFXJSE_Value(pIsolate));
         jsObjectValue->GetObjectProperty(propertyStr.AsStringC(),
                                          newPropertyValue.get());
-        if (FXJSE_Value_IsNull(newPropertyValue.get())) {
+        if (newPropertyValue->IsNull()) {
           isNull = TRUE;
         }
       }
     } else {
       isNull = TRUE;
     }
-  } else if (FXJSE_Value_IsObject(arg)) {
+  } else if (arg->IsObject()) {
     std::unique_ptr<CFXJSE_Value> defaultValue(new CFXJSE_Value(pIsolate));
     GetObjectDefaultValue(arg, defaultValue.get());
-    if (FXJSE_Value_IsNull(defaultValue.get())) {
+    if (defaultValue->IsNull()) {
       isNull = TRUE;
     }
   }
   return isNull;
 }
 
 // static
 int32_t CXFA_FM2JSContext::hvalue_get_array_length(CFXJSE_Value* pThis,
                                                    CFXJSE_Value* arg) {
+  if (!arg || !arg->IsArray())
+    return 0;
+
   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));
-    arg->GetObjectProperty("length", lengthValue.get());
-    iLength = lengthValue->ToInteger();
-  }
-  return iLength;
+  std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
+  arg->GetObjectProperty("length", lengthValue.get());
+  return lengthValue->ToInteger();
 }
 
 // static
 FX_BOOL CXFA_FM2JSContext::simpleValueCompare(CFXJSE_Value* pThis,
                                               CFXJSE_Value* firstValue,
                                               CFXJSE_Value* secondValue) {
+  if (!firstValue)
+    return FALSE;
+
   FX_BOOL bReturn = FALSE;
-  if (FXJSE_Value_IsUTF8String(firstValue)) {
+  if (firstValue->IsString()) {
     CFX_ByteString firstString, secondString;
     ValueToUTF8String(firstValue, firstString);
     ValueToUTF8String(secondValue, secondString);
     bReturn = firstString == secondString;
-  } else if (FXJSE_Value_IsNumber(firstValue)) {
+  } else if (firstValue->IsNumber()) {
     FX_FLOAT first = ValueToFloat(pThis, firstValue);
     FX_FLOAT second = ValueToFloat(pThis, secondValue);
     bReturn = (first == second);
-  } else if (FXJSE_Value_IsBoolean(firstValue)) {
+  } else if (firstValue->IsBoolean()) {
     bReturn = (firstValue->ToBoolean() == secondValue->ToBoolean());
-  } else if (FXJSE_Value_IsNull(firstValue) &&
-             FXJSE_Value_IsNull(secondValue)) {
+  } else if (firstValue->IsNull() && secondValue && secondValue->IsNull()) {
     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())) {
+    if (argsValue[i]->IsArray()) {
       std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
       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())) {
+    if (argsValue[i]->IsArray()) {
       std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
       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));
         argsValue[i]->GetObjectPropertyByIdx(1, propertyValue.get());
-        if (FXJSE_Value_IsNull(propertyValue.get())) {
+        if (propertyValue->IsNull()) {
           for (int32_t j = 2; j < iLength; j++) {
             argsValue[i]->GetObjectPropertyByIdx(j, jsObjectValue.get());
             GetObjectDefaultValue(jsObjectValue.get(), resultValues[index]);
             index++;
           }
         } else {
           CFX_ByteString propertyString;
           propertyValue->ToString(propertyString);
           for (int32_t j = 2; j < iLength; j++) {
             argsValue[i]->GetObjectPropertyByIdx(j, jsObjectValue.get());
             jsObjectValue->GetObjectProperty(propertyString.AsStringC(),
                                              resultValues[index]);
             index++;
           }
         }
       }
-    } else if (FXJSE_Value_IsObject(argsValue[i].get())) {
+    } else if (argsValue[i]->IsObject()) {
       GetObjectDefaultValue(argsValue[i].get(), resultValues[index]);
       index++;
     } else {
       resultValues[index]->Assign(argsValue[i].get());
       index++;
     }
   }
 }
 
 // static
@@ skipping 85 matching lines @@
   CFX_WideString wsSomExpression = CFX_WideString::FromUTF8(bsSomExp);
   int32_t iRet = -1;
   CXFA_Document* pDoc = ToJSContext(pThis, nullptr)->GetDocument();
   if (!pDoc) {
     return iRet;
   }
   CXFA_ScriptContext* pScriptContext = pDoc->GetScriptContext();
   CXFA_Object* pNode = nullptr;
   uint32_t dFlags = 0UL;
   if (bdotAccessor) {
-    if (FXJSE_Value_IsNull(pRefValue)) {
+    if (pRefValue && pRefValue->IsNull()) {
       pNode = pScriptContext->GetThisObject();
       dFlags = XFA_RESOLVENODE_Siblings | XFA_RESOLVENODE_Parent;
     } else {
       pNode = CXFA_ScriptContext::ToObject(pRefValue, nullptr);
       ASSERT(pNode);
       if (bHasNoResolveName) {
         CFX_WideString wsName;
         if (CXFA_Node* pXFANode = pNode->AsNode()) {
           pXFANode->GetAttribute(XFA_ATTRIBUTE_Name, wsName, FALSE);
         }
@@ skipping 40 matching lines @@
       resultValues[i] = new CFXJSE_Value(pIsolate);
       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)) {
+      if (pParentValue && pParentValue->IsObject()) {
         iSize = 1;
         resultValues = FX_Alloc(CFXJSE_Value*, 1);
         resultValues[0] = new CFXJSE_Value(pIsolate);
         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);
         resultValues[i]->Assign(objectProperties[i]);
       }
     }
   }
 }
 
 // static
 int32_t CXFA_FM2JSContext::ValueToInteger(CFXJSE_Value* pThis,
                                           CFXJSE_Value* pValue) {
+  if (!pValue)
+    return 0;
+
   v8::Isolate* pIsolate = ToJSContext(pThis, nullptr)->GetScriptRuntime();
   int32_t iValue = 0;
-  if (FXJSE_Value_IsArray(pValue)) {
+  if (pValue->IsArray()) {
     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));
     pValue->GetObjectPropertyByIdx(1, propertyValue.get());
     pValue->GetObjectPropertyByIdx(2, jsObjectValue.get());
-    if (FXJSE_Value_IsNull(propertyValue.get())) {
+    if (propertyValue->IsNull()) {
       GetObjectDefaultValue(jsObjectValue.get(), newPropertyValue.get());
     } else {
       CFX_ByteString propertyStr;
       propertyValue->ToString(propertyStr);
       jsObjectValue->GetObjectProperty(propertyStr.AsStringC(),
                                        newPropertyValue.get());
     }
     iValue = ValueToInteger(pThis, newPropertyValue.get());
     return iValue;
-  } else if (FXJSE_Value_IsObject(pValue)) {
+  } else if (pValue->IsObject()) {
     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)) {
+  } else if (pValue->IsString()) {
     CFX_ByteString szValue;
     pValue->ToString(szValue);
     iValue = FXSYS_atoi(szValue.c_str());
   } else {
     iValue = pValue->ToInteger();
   }
   return iValue;
 }
 
 // static
 FX_FLOAT CXFA_FM2JSContext::ValueToFloat(CFXJSE_Value* pThis,
                                          CFXJSE_Value* arg) {
+  if (!arg)
+    return 0.0f;
+
   v8::Isolate* pIsolate = ToJSContext(pThis, nullptr)->GetScriptRuntime();
   FX_FLOAT fRet = 0.0f;
-  if (FXJSE_Value_IsArray(arg)) {
+  if (arg->IsArray()) {
     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));
     arg->GetObjectPropertyByIdx(1, propertyValue.get());
     arg->GetObjectPropertyByIdx(2, jsObjectValue.get());
-    if (FXJSE_Value_IsNull(propertyValue.get())) {
+    if (propertyValue->IsNull()) {
       GetObjectDefaultValue(jsObjectValue.get(), newPropertyValue.get());
     } else {
       CFX_ByteString propertyStr;
       propertyValue->ToString(propertyStr);
       jsObjectValue->GetObjectProperty(propertyStr.AsStringC(),
                                        newPropertyValue.get());
     }
     fRet = ValueToFloat(pThis, newPropertyValue.get());
-  } else if (FXJSE_Value_IsObject(arg)) {
+  } else if (arg->IsObject()) {
     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)) {
+  } else if (arg->IsString()) {
     CFX_ByteString bsOutput;
     arg->ToString(bsOutput);
     fRet = (FX_FLOAT)XFA_ByteStringToDouble(bsOutput.AsStringC());
-  } else if (FXJSE_Value_IsUndefined(arg)) {
+  } else if (arg->IsUndefined()) {
     fRet = 0;
   } else {
     fRet = arg->ToFloat();
   }
   return fRet;
 }
 
 // static
 FX_DOUBLE CXFA_FM2JSContext::ValueToDouble(CFXJSE_Value* pThis,
                                            CFXJSE_Value* arg) {
+  if (!arg)
+    return 0;
+
   v8::Isolate* pIsolate = ToJSContext(pThis, nullptr)->GetScriptRuntime();
   FX_DOUBLE dRet = 0;
-  if (FXJSE_Value_IsArray(arg)) {
+  if (arg->IsArray()) {
     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));
     arg->GetObjectPropertyByIdx(1, propertyValue.get());
     arg->GetObjectPropertyByIdx(2, jsObjectValue.get());
-    if (FXJSE_Value_IsNull(propertyValue.get())) {
+    if (propertyValue->IsNull()) {
       GetObjectDefaultValue(jsObjectValue.get(), newPropertyValue.get());
     } else {
       CFX_ByteString propertyStr;
       propertyValue->ToString(propertyStr);
       jsObjectValue->GetObjectProperty(propertyStr.AsStringC(),
                                        newPropertyValue.get());
     }
     dRet = ValueToDouble(pThis, newPropertyValue.get());
-  } else if (FXJSE_Value_IsObject(arg)) {
+  } else if (arg->IsObject()) {
     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)) {
+  } else if (arg->IsString()) {
     CFX_ByteString bsOutput;
     arg->ToString(bsOutput);
     dRet = XFA_ByteStringToDouble(bsOutput.AsStringC());
-  } else if (FXJSE_Value_IsUndefined(arg)) {
+  } else if (arg->IsUndefined()) {
     dRet = 0;
   } else {
     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)) {
+  if (!src)
+    return 0;
+
+  if (src->IsArray()) {
     std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
     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));
     src->GetObjectPropertyByIdx(1, propertyValue.get());
     src->GetObjectPropertyByIdx(2, jsObjectValue.get());
-    if (FXJSE_Value_IsNull(propertyValue.get()))
+    if (propertyValue->IsNull())
       return ValueToDouble(pThis, jsObjectValue.get());
 
     CFX_ByteString propertyStr;
     propertyValue->ToString(propertyStr);
     std::unique_ptr<CFXJSE_Value> newPropertyValue(new CFXJSE_Value(pIsolate));
     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)) {
+  if (!arg)
+    return;
+
+  if (arg->IsNull() || arg->IsUndefined()) {
     szOutputString = "";
-  } else if (FXJSE_Value_IsBoolean(arg)) {
+  } else if (arg->IsBoolean()) {
     szOutputString = arg->ToBoolean() ? "1" : "0";
   } else {
     szOutputString = "";
     arg->ToString(szOutputString);
   }
 }
 
 // static.
 int32_t CXFA_FM2JSContext::Translate(const CFX_WideStringC& wsFormcalc,
                                      CFX_WideTextBuf& wsJavascript,
@@ skipping 16 matching lines @@
     return status;
   }
   program.TranslateProgram(wsJavascript);
   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_pFMClass(
+          CFXJSE_Class::Create(pScriptContext, &formcalc_fm2js_descriptor)),
       m_pValue(new CFXJSE_Value(pScriptIsolate)),
       m_pDocument(pDoc) {
   m_pValue.get()->SetNull();
   m_pValue.get()->SetObject(this, m_pFMClass);
 }
 
 CXFA_FM2JSContext::~CXFA_FM2JSContext() {}
 
 void CXFA_FM2JSContext::GlobalPropertyGetter(CFXJSE_Value* pValue) {
   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());
+      FX_UTF8Encode(wsMessage.c_str(), wsMessage.GetLength()).AsStringC());
 }