Push v8::Isolate into CFXJS_Engine class

fpdfsdk/javascript/global.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 "fpdfsdk/javascript/global.h"
 
 #include <vector>
 
@@ skipping 150 matching lines @@
                                          const std::vector<CJS_Value>& params,
                                          CJS_Value& vRet,
                                          CFX_WideString& sError) {
   CJS_Context* pContext = static_cast<CJS_Context*>(cc);
   CJS_Runtime* pRuntime = CJS_Runtime::FromContext(cc);
   if (params.size() != 2) {
     sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
     return FALSE;
   }
 
-  auto it = m_mapGlobal.find(params[0].ToCFXByteString(pRuntime->GetIsolate()));
+  auto it = m_mapGlobal.find(params[0].ToCFXByteString(pRuntime));
   if (it != m_mapGlobal.end()) {
     JSGlobalData* pData = it->second;
     if (!pData->bDeleted) {
-      pData->bPersistent = params[1].ToBool(pRuntime->GetIsolate());
+      pData->bPersistent = params[1].ToBool(pRuntime);
       return TRUE;
     }
   }
 
   sError = JSGetStringFromID(pContext, IDS_STRING_JSNOGLOBAL);
   return FALSE;
 }
 
 void JSGlobalAlternate::UpdateGlobalPersistentVariables() {
+  CJS_Runtime* pRuntime =
+      static_cast<CJS_Runtime*>(CFXJS_Engine::CurrentEngineFromIsolate(
+          m_pJSObject->ToV8Object()->GetIsolate()));
+
   for (int i = 0, sz = m_pGlobalData->GetSize(); i < sz; i++) {
     CJS_GlobalData_Element* pData = m_pGlobalData->GetAt(i);
     switch (pData->data.nType) {
       case JS_GlobalDataType::NUMBER:
         SetGlobalVariables(pData->data.sKey, JS_GlobalDataType::NUMBER,
                            pData->data.dData, false, "",
                            v8::Local<v8::Object>(), pData->bPersistent == 1);
-        FXJS_PutObjectNumber(nullptr, m_pJSObject->ToV8Object(),
-                             pData->data.sKey.UTF8Decode(), pData->data.dData);
+        pRuntime->PutObjectNumber(m_pJSObject->ToV8Object(),
+                                  pData->data.sKey.UTF8Decode(),
+                                  pData->data.dData);
         break;
       case JS_GlobalDataType::BOOLEAN:
         SetGlobalVariables(pData->data.sKey, JS_GlobalDataType::BOOLEAN, 0,
                            (bool)(pData->data.bData == 1), "",
                            v8::Local<v8::Object>(), pData->bPersistent == 1);
-        FXJS_PutObjectBoolean(nullptr, m_pJSObject->ToV8Object(),
-                              pData->data.sKey.UTF8Decode(),
-                              (bool)(pData->data.bData == 1));
+        pRuntime->PutObjectBoolean(m_pJSObject->ToV8Object(),
+                                   pData->data.sKey.UTF8Decode(),
+                                   (bool)(pData->data.bData == 1));
         break;
       case JS_GlobalDataType::STRING:
         SetGlobalVariables(pData->data.sKey, JS_GlobalDataType::STRING, 0,
                            false, pData->data.sData, v8::Local<v8::Object>(),
                            pData->bPersistent == 1);
-        FXJS_PutObjectString(nullptr, m_pJSObject->ToV8Object(),
-                             pData->data.sKey.UTF8Decode(),
-                             pData->data.sData.UTF8Decode());
+        pRuntime->PutObjectString(m_pJSObject->ToV8Object(),
+                                  pData->data.sKey.UTF8Decode(),
+                                  pData->data.sData.UTF8Decode());
         break;
       case JS_GlobalDataType::OBJECT: {
-        v8::Isolate* pRuntime = m_pJSObject->ToV8Object()->GetIsolate();
-        v8::Local<v8::Object> pObj =
-            FXJS_NewFxDynamicObj(pRuntime, nullptr, -1);
+        v8::Local<v8::Object> pObj = pRuntime->NewFxDynamicObj(-1);
 
         PutObjectProperty(pObj, &pData->data);
-
         SetGlobalVariables(pData->data.sKey, JS_GlobalDataType::OBJECT, 0,
                            false, "", pObj, pData->bPersistent == 1);
-        FXJS_PutObjectObject(nullptr, m_pJSObject->ToV8Object(),
-                             pData->data.sKey.UTF8Decode(), pObj);
+        pRuntime->PutObjectObject(m_pJSObject->ToV8Object(),
+                                  pData->data.sKey.UTF8Decode(), pObj);
       } break;
       case JS_GlobalDataType::NULLOBJ:
         SetGlobalVariables(pData->data.sKey, JS_GlobalDataType::NULLOBJ, 0,
                            false, "", v8::Local<v8::Object>(),
                            pData->bPersistent == 1);
-        FXJS_PutObjectNull(nullptr, m_pJSObject->ToV8Object(),
-                           pData->data.sKey.UTF8Decode());
+        pRuntime->PutObjectNull(m_pJSObject->ToV8Object(),
+                                pData->data.sKey.UTF8Decode());
         break;
     }
   }
 }
 
 void JSGlobalAlternate::CommitGlobalPersisitentVariables(IJS_Context* cc) {
   for (auto it = m_mapGlobal.begin(); it != m_mapGlobal.end(); ++it) {
     CFX_ByteString name = it->first;
     JSGlobalData* pData = it->second;
     if (pData->bDeleted) {
@@ skipping 25 matching lines @@
           m_pGlobalData->SetGlobalVariablePersistent(name, pData->bPersistent);
           break;
       }
     }
   }
 }
 
 void JSGlobalAlternate::ObjectToArray(IJS_Context* cc,
                                       v8::Local<v8::Object> pObj,
                                       CJS_GlobalVariableArray& array) {
-  v8::Isolate* isolate = pObj->GetIsolate();
   CJS_Runtime* pRuntime = CJS_Runtime::FromContext(cc);
-  std::vector<CFX_WideString> pKeyList =
-      FXJS_GetObjectPropertyNames(isolate, pObj);
+  std::vector<CFX_WideString> pKeyList = pRuntime->GetObjectPropertyNames(pObj);
   for (const auto& ws : pKeyList) {
     CFX_ByteString sKey = ws.UTF8Encode();
-    v8::Local<v8::Value> v = FXJS_GetObjectProperty(isolate, pObj, ws);
+    v8::Local<v8::Value> v = pRuntime->GetObjectProperty(pObj, ws);
     switch (CJS_Value::GetValueType(v)) {
       case CJS_Value::VT_number: {
         CJS_KeyValue* pObjElement = new CJS_KeyValue;
         pObjElement->nType = JS_GlobalDataType::NUMBER;
         pObjElement->sKey = sKey;
-        pObjElement->dData = FXJS_ToNumber(isolate, v);
+        pObjElement->dData = pRuntime->ToNumber(v);
         array.Add(pObjElement);
       } break;
       case CJS_Value::VT_boolean: {
         CJS_KeyValue* pObjElement = new CJS_KeyValue;
         pObjElement->nType = JS_GlobalDataType::BOOLEAN;
         pObjElement->sKey = sKey;
-        pObjElement->dData = FXJS_ToBoolean(isolate, v);
+        pObjElement->dData = pRuntime->ToBoolean(v);
         array.Add(pObjElement);
       } break;
       case CJS_Value::VT_string: {
         CFX_ByteString sValue =
-            CJS_Value(pRuntime, v).ToCFXByteString(pRuntime->GetIsolate());
+            CJS_Value(pRuntime, v).ToCFXByteString(pRuntime);
         CJS_KeyValue* pObjElement = new CJS_KeyValue;
         pObjElement->nType = JS_GlobalDataType::STRING;
         pObjElement->sKey = sKey;
         pObjElement->sData = sValue;
         array.Add(pObjElement);
       } break;
       case CJS_Value::VT_object: {
         CJS_KeyValue* pObjElement = new CJS_KeyValue;
         pObjElement->nType = JS_GlobalDataType::OBJECT;
         pObjElement->sKey = sKey;
-        ObjectToArray(cc, FXJS_ToObject(isolate, v), pObjElement->objData);
+        ObjectToArray(cc, pRuntime->ToObject(v), pObjElement->objData);
         array.Add(pObjElement);
       } break;
       case CJS_Value::VT_null: {
         CJS_KeyValue* pObjElement = new CJS_KeyValue;
         pObjElement->nType = JS_GlobalDataType::NULLOBJ;
         pObjElement->sKey = sKey;
         array.Add(pObjElement);
       } break;
       default:
         break;
     }
   }
 }
 
 void JSGlobalAlternate::PutObjectProperty(v8::Local<v8::Object> pObj,
                                           CJS_KeyValue* pData) {
+  CJS_Runtime* pRuntime = CJS_Runtime::CurrentRuntimeFromIsolate(
+      m_pJSObject->ToV8Object()->GetIsolate());
+
   for (int i = 0, sz = pData->objData.Count(); i < sz; i++) {
     CJS_KeyValue* pObjData = pData->objData.GetAt(i);
     switch (pObjData->nType) {
       case JS_GlobalDataType::NUMBER:
-        FXJS_PutObjectNumber(nullptr, pObj, pObjData->sKey.UTF8Decode(),
-                             pObjData->dData);
+        pRuntime->PutObjectNumber(pObj, pObjData->sKey.UTF8Decode(),
+                                  pObjData->dData);
         break;
       case JS_GlobalDataType::BOOLEAN:
-        FXJS_PutObjectBoolean(nullptr, pObj, pObjData->sKey.UTF8Decode(),
-                              pObjData->bData == 1);
+        pRuntime->PutObjectBoolean(pObj, pObjData->sKey.UTF8Decode(),
+                                   pObjData->bData == 1);
         break;
       case JS_GlobalDataType::STRING:
-        FXJS_PutObjectString(nullptr, pObj, pObjData->sKey.UTF8Decode(),
-                             pObjData->sData.UTF8Decode());
+        pRuntime->PutObjectString(pObj, pObjData->sKey.UTF8Decode(),
+                                  pObjData->sData.UTF8Decode());
         break;
       case JS_GlobalDataType::OBJECT: {
-        v8::Isolate* pRuntime = m_pJSObject->ToV8Object()->GetIsolate();
-        v8::Local<v8::Object> pNewObj =
-            FXJS_NewFxDynamicObj(pRuntime, nullptr, -1);
+        v8::Local<v8::Object> pNewObj = pRuntime->NewFxDynamicObj(-1);
         PutObjectProperty(pNewObj, pObjData);
-        FXJS_PutObjectObject(nullptr, pObj, pObjData->sKey.UTF8Decode(),
-                             pNewObj);
+        pRuntime->PutObjectObject(pObj, pObjData->sKey.UTF8Decode(), pNewObj);
       } break;
       case JS_GlobalDataType::NULLOBJ:
-        FXJS_PutObjectNull(nullptr, pObj, pObjData->sKey.UTF8Decode());
+        pRuntime->PutObjectNull(pObj, pObjData->sKey.UTF8Decode());
         break;
     }
   }
 }
 
 void JSGlobalAlternate::DestroyGlobalPersisitentVariables() {
   for (const auto& pair : m_mapGlobal) {
     delete pair.second;
   }
   m_mapGlobal.clear();
@@ skipping 73 matching lines @@
       pNewData->nType = JS_GlobalDataType::NULLOBJ;
       pNewData->bPersistent = bDefaultPersistent;
     } break;
     default:
       return FALSE;
   }
 
   m_mapGlobal[propname] = pNewData;
   return TRUE;
 }