Untangle bad depdenency from fxjse/ to fpdfsdk/

fxjse/include/fxjs_perisolatedata.h

Index: fxjse/include/fxjs_perisolatedata.h
diff --git a/fxjse/include/fxjs_perisolatedata.h b/fxjse/include/fxjs_perisolatedata.h
new file mode 100644
index 0000000000000000000000000000000000000000..8f22176ecd5b0d7b6b9d461acf4eea38c747882e
--- /dev/null
+++ b/fxjse/include/fxjs_perisolatedata.h
@@ -0,0 +1,166 @@
+// Copyright 2016 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
+
+#ifndef FXJSE_INCLUDE_FXJS_PERISOLATEDATA_H_
+#define FXJSE_INCLUDE_FXJS_PERISOLATEDATA_H_
+
+#include <v8-util.h>
+#include <v8.h>
+
+#include "core/fxcrt/include/fx_string.h"
+
+class CFXJSE_RuntimeData;
+class CFXJS_ObjDefinition;
+class IJS_Runtime;  // A native runtime, typically owns the v8::Context.
+
+using FXJS_CONSTRUCTOR = void (*)(IJS_Runtime* cc, v8::Local<v8::Object> obj);
+using FXJS_DESTRUCTOR = void (*)(v8::Local<v8::Object> obj);
+
+enum FXJSOBJTYPE {
+  FXJSOBJTYPE_DYNAMIC = 0,  // Created by native method and returned to JS.
+  FXJSOBJTYPE_STATIC,       // Created by init and hung off of global object.
+  FXJSOBJTYPE_GLOBAL,       // The global object itself (may only appear once).
+};
+
+// Global weak map to save dynamic objects.
+class V8TemplateMapTraits : public v8::StdMapTraits<void*, v8::Object> {
+ public:
+  typedef v8::GlobalValueMap<void*, v8::Object, V8TemplateMapTraits> MapType;
+  typedef void WeakCallbackDataType;
+
+  static WeakCallbackDataType* WeakCallbackParameter(
+      MapType* map,
+      void* key,
+      const v8::Local<v8::Object>& value) {
+    return key;
+  }
+  static MapType* MapFromWeakCallbackInfo(
+      const v8::WeakCallbackInfo<WeakCallbackDataType>&);
+
+  static void* KeyFromWeakCallbackInfo(
+      const v8::WeakCallbackInfo<WeakCallbackDataType>& data) {
+    return data.GetParameter();
+  }
+  static const v8::PersistentContainerCallbackType kCallbackType =
+      v8::kWeakWithInternalFields;
+  static void DisposeWeak(
+      const v8::WeakCallbackInfo<WeakCallbackDataType>& data) {}
+  static void OnWeakCallback(
+      const v8::WeakCallbackInfo<WeakCallbackDataType>& data) {}
+  static void Dispose(v8::Isolate* isolate,
+                      v8::Global<v8::Object> value,
+                      void* key);
+  static void DisposeCallbackData(WeakCallbackDataType* callbackData) {}
+};
+
+class V8TemplateMap {
+ public:
+  typedef v8::GlobalValueMap<void*, v8::Object, V8TemplateMapTraits> MapType;
+
+  void set(void* key, v8::Local<v8::Object> handle) {
+    ASSERT(!m_map.Contains(key));
+    m_map.Set(key, handle);
+  }
+  explicit V8TemplateMap(v8::Isolate* isolate) : m_map(isolate) {}
+  friend class V8TemplateMapTraits;
+
+ private:
+  MapType m_map;
+};
+
+class FXJS_PerIsolateData {
+ public:
+  static void SetEmbedderDataSlot(unsigned int slot);
+  static unsigned int EmbedderDataSlot();
+
+  static void SetUp(v8::Isolate* pIsolate);
+  static FXJS_PerIsolateData* Get(v8::Isolate* pIsolate);
+
+  void CreateDynamicObjsMap(v8::Isolate* pIsolate) {
+    if (!m_pDynamicObjsMap)
+      m_pDynamicObjsMap = new V8TemplateMap(pIsolate);
+  }
+  void ReleaseDynamicObjsMap() {
+    delete m_pDynamicObjsMap;
+    m_pDynamicObjsMap = nullptr;
+  }
+
+  std::vector<CFXJS_ObjDefinition*> m_ObjectDefnArray;
+#ifdef PDF_ENABLE_XFA
+  CFXJSE_RuntimeData* m_pFXJSERuntimeData;
+#endif  // PDF_ENABLE_XFA
+  V8TemplateMap* m_pDynamicObjsMap;
+
+ protected:
+#ifndef PDF_ENABLE_XFA
+  FXJS_PerIsolateData() : m_pDynamicObjsMap(nullptr) {}
+#else   // PDF_ENABLE_XFA
+  FXJS_PerIsolateData()
+      : m_pFXJSERuntimeData(nullptr), m_pDynamicObjsMap(nullptr) {}
+#endif  // PDF_ENABLE_XFA
+};
+
+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;
+};
+
+#endif  // FXJSE_INCLUDE_FXJS_PERISOLATEDATA_H_