[wasm] Managed<T> ensures T's lifetime does not leak past Isolate's

src/isolate.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/isolate.h"
 
 #include <stdlib.h>
 
 #include <fstream>  // NOLINT(readability/streams)
 #include <sstream>
@@ skipping 2012 matching lines @@
 }
 
 
 Isolate::ThreadDataTable::~ThreadDataTable() {
   // TODO(svenpanne) The assertion below would fire if an embedder does not
   // cleanly dispose all Isolates before disposing v8, so we are conservative
   // and leave it out for now.
   // DCHECK_NULL(list_);
 }
 
+void Isolate::ReleaseManagedLifelines() {
+  Isolate::ManagedLifeline* current = managed_lifelines_root_.next_;
+  while (current != nullptr) {
+    Isolate::ManagedLifeline* next = current->next_;
+    current->Dispose();
+    delete current;
+    current = next;
+  }
+}
+
+Isolate::ManagedLifeline* Isolate::RegisterForReleaseAtTeardown(
+    void* value, Isolate::ManagedLifeline::Deleter deleter) {
+  DCHECK_NOT_NULL(value);
+  DCHECK_NOT_NULL(deleter);
+
+  Isolate::ManagedLifeline* ret = new Isolate::ManagedLifeline();
+  ret->value_ = value;
+  ret->deleter_ = deleter;
+  // Insert at head. We keep the head alive for the lifetime of the Isolate
+  // because otherwise we can't reset the head, should we delete it before
+  // the isolate expires
+  Isolate::ManagedLifeline* next = managed_lifelines_root_.next_;
+  managed_lifelines_root_.next_ = ret;
+  ret->prev_ = &managed_lifelines_root_;
+  ret->next_ = next;
+  if (next != nullptr) next->prev_ = ret;
+  return ret;
+}
+
+void Isolate::UnregisterFromReleaseAtTeardown(
+    Isolate::ManagedLifeline** lifeline_ptr) {
+  DCHECK_NOT_NULL(lifeline_ptr);
+  Isolate::ManagedLifeline* lifeline = *lifeline_ptr;
+  DCHECK_NOT_NULL(lifeline->prev_);
+
+  lifeline->prev_->next_ = lifeline->next_;
+  if (lifeline->next_ != nullptr) lifeline->next_->prev_ = lifeline->prev_;
+  delete lifeline;
+  *lifeline_ptr = nullptr;
+}
 
 Isolate::PerIsolateThreadData::~PerIsolateThreadData() {
 #if defined(USE_SIMULATOR)
   delete simulator_;
 #endif
 }
 
 
 Isolate::PerIsolateThreadData*
     Isolate::ThreadDataTable::Lookup(Isolate* isolate,
@@ skipping 349 matching lines @@
 
   delete cpu_profiler_;
   cpu_profiler_ = NULL;
 
   code_event_dispatcher_.reset();
 
   delete root_index_map_;
   root_index_map_ = NULL;
 
   ClearSerializerData();
+  ReleaseManagedLifelines();
 }
 
 
 void Isolate::SetIsolateThreadLocals(Isolate* isolate,
                                      PerIsolateThreadData* data) {
   base::Thread::SetThreadLocal(isolate_key_, isolate);
   base::Thread::SetThreadLocal(per_isolate_thread_data_key_, data);
 }
 
 
@@ skipping 1241 matching lines @@
   // Then check whether this scope intercepts.
   if ((flag & intercept_mask_)) {
     intercepted_flags_ |= flag;
     return true;
   }
   return false;
 }
 
 }  // namespace internal
 }  // namespace v8