Simplify memory management for per isolate data

fxjs/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 "fxjs/include/fxjs_v8.h"
 
 #include <vector>
 
@@ skipping 20 matching lines @@
 };
 
 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];
+    return FXJS_PerIsolateData::Get(pIsolate)->m_ObjectDefnArray[id].get();
   }
 
   CFXJS_ObjDefinition(v8::Isolate* isolate,
                       const wchar_t* sObjName,
                       FXJSOBJTYPE eObjType,
                       CFXJS_Engine::Constructor pConstructor,
                       CFXJS_Engine::Destructor pDestructor)
       : m_ObjName(sObjName),
         m_ObjType(eObjType),
         m_pConstructor(pConstructor),
@@ skipping 11 matching lines @@
               .ToLocalChecked());
     }
     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);
+    pData->m_ObjectDefnArray.emplace_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());
   }
 
@@ skipping 59 matching lines @@
   if (!pObjDef)
     return;
   if (pObjDef->m_pDestructor)
     pObjDef->m_pDestructor(pEngine, obj);
   CFXJS_Engine::FreeObjectPrivate(obj);
 }
 
 V8TemplateMapTraits::MapType* V8TemplateMapTraits::MapFromWeakCallbackInfo(
     const v8::WeakCallbackInfo<WeakCallbackDataType>& data) {
   V8TemplateMap* pMap =
-      (FXJS_PerIsolateData::Get(data.GetIsolate()))->m_pDynamicObjsMap;
+      (FXJS_PerIsolateData::Get(data.GetIsolate()))->m_pDynamicObjsMap.get();
   return pMap ? &pMap->m_map : nullptr;
 }
 
 void FXJS_Initialize(unsigned int embedderDataSlot, v8::Isolate* pIsolate) {
   if (g_isolate) {
     ASSERT(g_embedderDataSlot == embedderDataSlot);
     ASSERT(g_isolate == pIsolate);
     return;
   }
   g_embedderDataSlot = embedderDataSlot;
@@ skipping 35 matching lines @@
 void V8TemplateMap::set(void* key, v8::Local<v8::Object> handle) {
   ASSERT(!m_map.Contains(key));
   m_map.Set(key, handle);
 }
 
 FXJS_PerIsolateData::~FXJS_PerIsolateData() {}
 
 // static
 void FXJS_PerIsolateData::SetUp(v8::Isolate* pIsolate) {
   if (!pIsolate->GetData(g_embedderDataSlot))
-    pIsolate->SetData(g_embedderDataSlot, new FXJS_PerIsolateData());
+    pIsolate->SetData(g_embedderDataSlot, new FXJS_PerIsolateData(pIsolate));
 }
 
 // static
 FXJS_PerIsolateData* FXJS_PerIsolateData::Get(v8::Isolate* pIsolate) {
   return static_cast<FXJS_PerIsolateData*>(
       pIsolate->GetData(g_embedderDataSlot));
 }
 
-FXJS_PerIsolateData::FXJS_PerIsolateData() : m_pDynamicObjsMap(nullptr) {}
+FXJS_PerIsolateData::FXJS_PerIsolateData(v8::Isolate* pIsolate)
+    : m_pDynamicObjsMap(new V8TemplateMap(pIsolate)) {}
 
 CFXJS_Engine::CFXJS_Engine() : m_isolate(nullptr) {}
 
 CFXJS_Engine::CFXJS_Engine(v8::Isolate* pIsolate) : m_isolate(pIsolate) {}
 
 CFXJS_Engine::~CFXJS_Engine() {
   m_V8PersistentContext.Reset();
 }
 
 // static
@@ skipping 144 matching lines @@
   v8::HandleScope handle_scope(m_isolate);
 
   // This has to happen before we call GetGlobalObjectTemplate because that
   // method gets the PerIsolateData from m_isolate.
   FXJS_PerIsolateData::SetUp(m_isolate);
 
   v8::Local<v8::Context> v8Context =
       v8::Context::New(m_isolate, nullptr, GetGlobalObjectTemplate(m_isolate));
   v8::Context::Scope context_scope(v8Context);
 
-  FXJS_PerIsolateData* pData = FXJS_PerIsolateData::Get(m_isolate);
-  if (!pData)
-    return;
-  pData->CreateDynamicObjsMap(m_isolate);
   v8Context->SetAlignedPointerInEmbedderData(kPerContextDataIndex, this);
 
   int maxID = CFXJS_ObjDefinition::MaxID(m_isolate);
   m_StaticObjects.resize(maxID + 1);
   for (int i = 0; i < maxID; ++i) {
     CFXJS_ObjDefinition* pObjDef = CFXJS_ObjDefinition::ForID(m_isolate, i);
     if (pObjDef->m_ObjType == FXJSOBJTYPE_GLOBAL) {
       v8Context->Global()
           ->GetPrototype()
           ->ToObject(v8Context)
@@ skipping 51 matching lines @@
         pObjDef->m_pDestructor(this, pObj);
       FreeObjectPrivate(pObj);
     }
   }
 
   m_V8PersistentContext.Reset();
 
   if (m_isolate == g_isolate && --g_isolate_ref_count > 0)
     return;
 
-  pData->ReleaseDynamicObjsMap();
-  for (int i = 0; i < maxID; ++i)
-    delete CFXJS_ObjDefinition::ForID(m_isolate, i);
-
+  delete pData;
   m_isolate->SetData(g_embedderDataSlot, nullptr);
-  delete pData;
 }
 
 int CFXJS_Engine::Execute(const CFX_WideString& script, FXJSErr* pError) {
   v8::Isolate::Scope isolate_scope(m_isolate);
   v8::TryCatch try_catch(m_isolate);
   CFX_ByteString bsScript = script.UTF8Encode();
   v8::Local<v8::Context> context = m_isolate->GetCurrentContext();
   v8::Local<v8::Script> compiled_script;
   if (!v8::Script::Compile(context,
                            v8::String::NewFromUtf8(m_isolate, bsScript.c_str(),
@@ skipping 323 matching lines @@
 }
 
 void CFXJS_Engine::SetConstArray(const CFX_WideString& name,
                                  v8::Local<v8::Array> array) {
   m_ConstArrays[name] = v8::Global<v8::Array>(GetIsolate(), array);
 }
 
 v8::Local<v8::Array> CFXJS_Engine::GetConstArray(const CFX_WideString& name) {
   return v8::Local<v8::Array>::New(GetIsolate(), m_ConstArrays[name]);
 }