Use V8's new SetWeak method

atom/common/api/object_life_monitor.cc

@@ -5,32 +5,52 @@
 
 #include "atom/common/api/object_life_monitor.h"
 
-#include "native_mate/compat.h"
+#include "base/bind.h"
+#include "base/message_loop/message_loop.h"
 
 namespace atom {
 
 // static
 void ObjectLifeMonitor::BindTo(v8::Isolate* isolate,
                                v8::Local<v8::Object> target,
-                               v8::Local<v8::Value> destructor) {
-  target->SetHiddenValue(MATE_STRING_NEW(isolate, "destructor"), destructor);
-
-  ObjectLifeMonitor* olm = new ObjectLifeMonitor();
-  olm->handle_.reset(isolate, target);
-  olm->handle_.SetWeak(olm, WeakCallback);
+                               v8::Local<v8::Function> destructor) {
+  new ObjectLifeMonitor(isolate, target, destructor);
 }
 
-ObjectLifeMonitor::ObjectLifeMonitor() {
+ObjectLifeMonitor::ObjectLifeMonitor(v8::Isolate* isolate,
+                                     v8::Local<v8::Object> target,
+                                     v8::Local<v8::Function> destructor)
+    : isolate_(isolate),
+      context_(isolate, isolate->GetCurrentContext()),
+      target_(isolate, target),
+      destructor_(isolate, destructor),
+      weak_ptr_factory_(this) {
+  target_.SetWeak(this, OnObjectGC, v8::WeakCallbackType::kParameter);
 }
 
 // static
-void ObjectLifeMonitor::WeakCallback(
-    const v8::WeakCallbackData<v8::Object, ObjectLifeMonitor>& data) {
-  // destructor.call(object, object);
-  v8::Local<v8::Object> obj = data.GetValue();
-  v8::Local<v8::Function>::Cast(obj->GetHiddenValue(
-      MATE_STRING_NEW(data.GetIsolate(), "destructor")))->Call(obj, 0, NULL);
-  delete data.GetParameter();
+void ObjectLifeMonitor::OnObjectGC(
+    const v8::WeakCallbackInfo<ObjectLifeMonitor>& data) {
+  // Usually FirstWeakCallback should do nothing other than reset |object_|
+  // and then set a second weak callback to run later. We can sidestep that,
+  // because posting a task to the current message loop is all but free - but
+  // DO NOT add any more work to this method. The only acceptable place to add
+  // code is RunCallback.
+  ObjectLifeMonitor* self = data.GetParameter();
+  self->target_.Reset();
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&ObjectLifeMonitor::RunCallback,
+                            self->weak_ptr_factory_.GetWeakPtr()));
+}
+
+void ObjectLifeMonitor::RunCallback() {
+  v8::HandleScope handle_scope(isolate_);
+  v8::Local<v8::Context> context = v8::Local<v8::Context>::New(
+      isolate_, context_);
+  v8::Context::Scope context_scope(context);
+  v8::Local<v8::Function>::New(isolate_, destructor_)->Call(
+      context->Global(), 0, nullptr);
+  delete this;
 }
 
 }  // namespace atom

atom/common/api/object_life_monitor.h

@@ -6,7 +6,8 @@
 #define ATOM_COMMON_API_OBJECT_LIFE_MONITOR_H_
 
 #include "base/basictypes.h"
-#include "native_mate/scoped_persistent.h"
+#include "base/memory/weak_ptr.h"
+#include "v8/include/v8.h"
 
 namespace atom {
 
@@ -14,15 +15,23 @@ class ObjectLifeMonitor {
  public:
   static void BindTo(v8::Isolate* isolate,
                      v8::Local<v8::Object> target,
-                     v8::Local<v8::Value> destructor);
+                     v8::Local<v8::Function> destructor);
 
  private:
-  ObjectLifeMonitor();
+  ObjectLifeMonitor(v8::Isolate* isolate,
+                    v8::Local<v8::Object> target,
+                    v8::Local<v8::Function> destructor);
 
-  static void WeakCallback(
-      const v8::WeakCallbackData<v8::Object, ObjectLifeMonitor>& data);
+  static void OnObjectGC(const v8::WeakCallbackInfo<ObjectLifeMonitor>& data);
 
-  mate::ScopedPersistent<v8::Object> handle_;
+  void RunCallback();
+
+  v8::Isolate* isolate_;
+  v8::Global<v8::Context> context_;
+  v8::Global<v8::Object> target_;
+  v8::Global<v8::Function> destructor_;
+
+  base::WeakPtrFactory<ObjectLifeMonitor> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ObjectLifeMonitor);
 };

atom/common/id_weak_map.cc

@@ -10,6 +10,23 @@
 
 namespace atom {
 
+namespace {
+
+struct ObjectKey {
+  ObjectKey(int id, IDWeakMap* map) : id(id), map(map) {}
+  int id;
+  IDWeakMap* map;
+};
+
+void OnObjectGC(const v8::WeakCallbackInfo<ObjectKey>& data) {
+  ObjectKey* key = data.GetParameter();
+  LOG(ERROR) << "OnObjectGC: " << key->id;
+  key->map->Remove(key->id);
+  delete key;
+}
+
+}  // namespace
+
 IDWeakMap::IDWeakMap() : next_id_(0) {
 }
 
@@ -18,11 +35,9 @@ IDWeakMap::~IDWeakMap() {
 
 int32_t IDWeakMap::Add(v8::Isolate* isolate, v8::Local<v8::Object> object) {
   int32_t id = GetNextID();
-  object->SetHiddenValue(mate::StringToSymbol(isolate, "IDWeakMapKey"),
-                         mate::Converter<int32_t>::ToV8(isolate, id));
-
   auto global = make_linked_ptr(new v8::Global<v8::Object>(isolate, object));
-  global->SetWeak(this, &WeakCallback);
+  ObjectKey* key = new ObjectKey(id, this);
+  global->SetWeak(key, OnObjectGC, v8::WeakCallbackType::kParameter);
   map_[id] = global;
   return id;
 }
@@ -71,12 +86,4 @@ int32_t IDWeakMap::GetNextID() {
   return ++next_id_;
 }
 
-// static
-void IDWeakMap::WeakCallback(
-    const v8::WeakCallbackData<v8::Object, IDWeakMap>& data) {
-  int32_t id = data.GetValue()->GetHiddenValue(
-      mate::StringToV8(data.GetIsolate(), "IDWeakMapKey"))->Int32Value();
-  data.GetParameter()->Remove(id);
-}
-
 }  // namespace atom

atom/common/id_weak_map.h

@@ -44,9 +44,6 @@ class IDWeakMap {
   // Returns next available ID.
   int32_t GetNextID();
 
-  static void WeakCallback(
-      const v8::WeakCallbackData<v8::Object, IDWeakMap>& data);
-
   // ID of next stored object.
   int32_t next_id_;
 

vendor/native_mate

@@ -1 +1 @@
-Subproject commit f5e34deb1a5226b4e7e620cb65fce0225471d4d9
+Subproject commit 8ca005eb41591f583ebab804945311903f866ad6