Untangle bad depdenency from fxjse/ to fpdfsdk/

fpdfsdk/jsapi/fxjs_v8.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/jsapi/include/fxjs_v8.h"
 
 #include <vector>
 
 #include "core/fxcrt/include/fx_basic.h"
 
 const wchar_t kFXJSValueNameString[] = L"string";
 const wchar_t kFXJSValueNameNumber[] = L"number";
 const wchar_t kFXJSValueNameBoolean[] = L"boolean";
 const wchar_t kFXJSValueNameDate[] = L"date";
 const wchar_t kFXJSValueNameObject[] = L"object";
 const wchar_t kFXJSValueNameFxobj[] = L"fxobj";
 const wchar_t kFXJSValueNameNull[] = L"null";
 const wchar_t kFXJSValueNameUndefined[] = L"undefined";
 
 // Keep this consistent with the values defined in gin/public/context_holder.h
 // (without actually requiring a dependency on gin itself for the standalone
 // embedders of PDFIum). The value we want to use is:
 //   kPerContextDataStartIndex + kEmbedderPDFium, which is 3.
 static const unsigned int kPerContextDataIndex = 3u;
-static unsigned int g_embedderDataSlot = 1u;
 static v8::Isolate* g_isolate = nullptr;
 static size_t g_isolate_ref_count = 0;
 static FXJS_ArrayBufferAllocator* g_arrayBufferAllocator = nullptr;
 static v8::Global<v8::ObjectTemplate>* g_DefaultGlobalObjectTemplate = nullptr;
 
 class CFXJS_PerObjectData {
  public:
   explicit CFXJS_PerObjectData(int nObjDefID)
       : m_ObjDefID(nObjDefID), m_pPrivate(nullptr) {}
 
   const int m_ObjDefID;
   void* m_pPrivate;
 };
 
-class CFXJS_ObjDefinition {
- public:
-  static int MaxID(v8::Isolate* pIsolate) {
-    return FXJS_PerIsolateData::Get(pIsolate)->m_ObjectDefnArray.size();
-  }
-
-  static CFXJS_ObjDefinition* ForID(v8::Isolate* pIsolate, int id) {
-    // Note: GetAt() halts if out-of-range even in release builds.
-    return FXJS_PerIsolateData::Get(pIsolate)->m_ObjectDefnArray[id];
-  }
-
-  CFXJS_ObjDefinition(v8::Isolate* isolate,
-                      const wchar_t* sObjName,
-                      FXJSOBJTYPE eObjType,
-                      FXJS_CONSTRUCTOR pConstructor,
-                      FXJS_DESTRUCTOR pDestructor)
-      : m_ObjName(sObjName),
-        m_ObjType(eObjType),
-        m_pConstructor(pConstructor),
-        m_pDestructor(pDestructor),
-        m_pIsolate(isolate) {
-    v8::Isolate::Scope isolate_scope(isolate);
-    v8::HandleScope handle_scope(isolate);
-
-    v8::Local<v8::FunctionTemplate> fun = v8::FunctionTemplate::New(isolate);
-    fun->InstanceTemplate()->SetInternalFieldCount(2);
-    m_FunctionTemplate.Reset(isolate, fun);
-
-    v8::Local<v8::Signature> sig = v8::Signature::New(isolate, fun);
-    m_Signature.Reset(isolate, sig);
-  }
-
-  int AssignID() {
-    FXJS_PerIsolateData* pData = FXJS_PerIsolateData::Get(m_pIsolate);
-    pData->m_ObjectDefnArray.push_back(this);
-    return pData->m_ObjectDefnArray.size() - 1;
-  }
-
-  v8::Local<v8::ObjectTemplate> GetInstanceTemplate() {
-    v8::EscapableHandleScope scope(m_pIsolate);
-    v8::Local<v8::FunctionTemplate> function =
-        m_FunctionTemplate.Get(m_pIsolate);
-    return scope.Escape(function->InstanceTemplate());
-  }
-
-  v8::Local<v8::Signature> GetSignature() {
-    v8::EscapableHandleScope scope(m_pIsolate);
-    return scope.Escape(m_Signature.Get(m_pIsolate));
-  }
-
-  const wchar_t* const m_ObjName;
-  const FXJSOBJTYPE m_ObjType;
-  const FXJS_CONSTRUCTOR m_pConstructor;
-  const FXJS_DESTRUCTOR m_pDestructor;
-
-  v8::Isolate* m_pIsolate;
-  v8::Global<v8::FunctionTemplate> m_FunctionTemplate;
-  v8::Global<v8::Signature> m_Signature;
-};
-
 static v8::Local<v8::ObjectTemplate> GetGlobalObjectTemplate(
     v8::Isolate* pIsolate) {
   int maxID = CFXJS_ObjDefinition::MaxID(pIsolate);
   for (int i = 0; i < maxID; ++i) {
     CFXJS_ObjDefinition* pObjDef = CFXJS_ObjDefinition::ForID(pIsolate, i);
     if (pObjDef->m_ObjType == FXJSOBJTYPE_GLOBAL)
       return pObjDef->GetInstanceTemplate();
   }
   if (!g_DefaultGlobalObjectTemplate) {
     g_DefaultGlobalObjectTemplate = new v8::Global<v8::ObjectTemplate>;
@@ skipping 35 matching lines @@
 
 V8TemplateMapTraits::MapType* V8TemplateMapTraits::MapFromWeakCallbackInfo(
     const v8::WeakCallbackInfo<WeakCallbackDataType>& data) {
   V8TemplateMap* pMap =
       (FXJS_PerIsolateData::Get(data.GetIsolate()))->m_pDynamicObjsMap;
   return pMap ? &pMap->m_map : nullptr;
 }
 
 void FXJS_Initialize(unsigned int embedderDataSlot, v8::Isolate* pIsolate) {
   if (g_isolate) {
-    ASSERT(g_embedderDataSlot == embedderDataSlot);
+    ASSERT(FXJS_PerIsolateData::EmbedderDataSlot() == embedderDataSlot);
     ASSERT(g_isolate == pIsolate);
     return;
   }
-  g_embedderDataSlot = embedderDataSlot;
+  FXJS_PerIsolateData::SetEmbedderDataSlot(embedderDataSlot);
   g_isolate = pIsolate;
 }
 
 void FXJS_Release() {
   ASSERT(!g_isolate || g_isolate_ref_count == 0);
   delete g_DefaultGlobalObjectTemplate;
   g_DefaultGlobalObjectTemplate = nullptr;
   g_isolate = nullptr;
 
   delete g_arrayBufferAllocator;
@@ skipping 11 matching lines @@
   v8::Isolate::CreateParams params;
   params.array_buffer_allocator = g_arrayBufferAllocator;
   *pResultIsolate = v8::Isolate::New(params);
   return true;
 }
 
 size_t FXJS_GlobalIsolateRefCount() {
   return g_isolate_ref_count;
 }
 
-// static
-void FXJS_PerIsolateData::SetUp(v8::Isolate* pIsolate) {
-  if (!pIsolate->GetData(g_embedderDataSlot))
-    pIsolate->SetData(g_embedderDataSlot, new FXJS_PerIsolateData());
-}
-
-// static
-FXJS_PerIsolateData* FXJS_PerIsolateData::Get(v8::Isolate* pIsolate) {
-  return static_cast<FXJS_PerIsolateData*>(
-      pIsolate->GetData(g_embedderDataSlot));
-}
-
 int FXJS_DefineObj(v8::Isolate* pIsolate,
                    const wchar_t* sObjName,
                    FXJSOBJTYPE eObjType,
                    FXJS_CONSTRUCTOR pConstructor,
                    FXJS_DESTRUCTOR pDestructor) {
   v8::Isolate::Scope isolate_scope(pIsolate);
   v8::HandleScope handle_scope(pIsolate);
 
   FXJS_PerIsolateData::SetUp(pIsolate);
   CFXJS_ObjDefinition* pObjDef = new CFXJS_ObjDefinition(
@@ skipping 174 matching lines @@
     }
   }
 
   if (pIsolate == g_isolate && --g_isolate_ref_count > 0)
     return;
 
   pData->ReleaseDynamicObjsMap();
   for (int i = 0; i < maxID; ++i)
     delete CFXJS_ObjDefinition::ForID(pIsolate, i);
 
-  pIsolate->SetData(g_embedderDataSlot, nullptr);
+  pIsolate->SetData(FXJS_PerIsolateData::EmbedderDataSlot(), nullptr);
   delete pData;
 }
 
 IJS_Runtime* FXJS_GetRuntimeFromIsolate(v8::Isolate* pIsolate) {
   v8::Local<v8::Context> context = pIsolate->GetCurrentContext();
   return static_cast<IJS_Runtime*>(
       context->GetAlignedPointerFromEmbedderData(kPerContextDataIndex));
 }
 
 #ifdef PDF_ENABLE_XFA
@@ skipping 397 matching lines @@
                                   v8::Local<v8::Value> pValue) {
   if (pValue.IsEmpty())
     return v8::Local<v8::Array>();
   v8::Local<v8::Context> context = pIsolate->GetCurrentContext();
   return v8::Local<v8::Array>::Cast(pValue->ToObject(context).ToLocalChecked());
 }
 
 void FXJS_ValueCopy(v8::Local<v8::Value>& pTo, v8::Local<v8::Value> pFrom) {
   pTo = pFrom;
 }