Merge pull request #2046 from atom/id-weak-map

Track native JS objects in C++

atom/common/api/atom_api_id_weak_map.cc

@@ -4,9 +4,6 @@
 
 #include "atom/common/api/atom_api_id_weak_map.h"
 
-#include <algorithm>
-
-#include "base/logging.h"
 #include "native_mate/constructor.h"
 #include "native_mate/object_template_builder.h"
 
@@ -16,53 +13,37 @@ namespace atom {
 
 namespace api {
 
-IDWeakMap::IDWeakMap()
-    : next_id_(0) {
+IDWeakMap::IDWeakMap() {
 }
 
 IDWeakMap::~IDWeakMap() {
 }
 
 int32_t IDWeakMap::Add(v8::Isolate* isolate, v8::Local<v8::Object> object) {
-  int32_t key = GetNextID();
-  object->SetHiddenValue(mate::StringToV8(isolate, "IDWeakMapKey"),
-                         mate::Converter<int32_t>::ToV8(isolate, key));
-
-  map_[key] = new mate::RefCountedPersistent<v8::Object>(isolate, object);
-  map_[key]->SetWeak(this, WeakCallback);
-  return key;
+  return map_.Add(isolate, object);
 }
 
 v8::Local<v8::Value> IDWeakMap::Get(v8::Isolate* isolate, int32_t key) {
-  if (!Has(key)) {
-    node::ThrowError(isolate, "Invalid key");
+  v8::MaybeLocal<v8::Object> result = map_.Get(isolate, key);
+  if (result.IsEmpty()) {
+    isolate->ThrowException(v8::Exception::Error(
+        mate::StringToV8(isolate, "Invalid key")));
     return v8::Undefined(isolate);
+  } else {
+    return result.ToLocalChecked();
   }
-
-  return map_[key]->NewHandle();
 }
 
 bool IDWeakMap::Has(int32_t key) const {
-  return map_.find(key) != map_.end();
+  return map_.Has(key);
 }
 
 std::vector<int32_t> IDWeakMap::Keys() const {
-  std::vector<int32_t> keys;
-  keys.reserve(map_.size());
-  for (auto it = map_.begin(); it != map_.end(); ++it)
-    keys.push_back(it->first);
-  return keys;
+  return map_.Keys();
 }
 
 void IDWeakMap::Remove(int32_t key) {
-  if (Has(key))
-    map_.erase(key);
-  else
-    LOG(WARNING) << "Object with key " << key << " is being GCed for twice.";
-}
-
-int IDWeakMap::GetNextID() {
-  return ++next_id_;
+  map_.Remove(key);
 }
 
 // static
@@ -76,14 +57,6 @@ void IDWeakMap::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("remove", &IDWeakMap::Remove);
 }
 
-// static
-void IDWeakMap::WeakCallback(
-    const v8::WeakCallbackData<v8::Object, IDWeakMap>& data) {
-  int32_t key = data.GetValue()->GetHiddenValue(
-      mate::StringToV8(data.GetIsolate(), "IDWeakMapKey"))->Int32Value();
-  data.GetParameter()->Remove(key);
-}
-
 }  // namespace api
 
 }  // namespace atom
@@ -99,7 +72,7 @@ void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
       isolate,
       "IDWeakMap",
       base::Bind(&mate::NewOperatorFactory<IDWeakMap>));
-  exports->Set(mate::StringToV8(isolate, "IDWeakMap"), constructor);
+  exports->Set(mate::StringToSymbol(isolate, "IDWeakMap"), constructor);
 }
 
 }  // namespace

atom/common/api/atom_api_id_weak_map.h

@@ -6,11 +6,9 @@
 #ifndef ATOM_COMMON_API_ATOM_API_ID_WEAK_MAP_H_
 #define ATOM_COMMON_API_ATOM_API_ID_WEAK_MAP_H_
 
-#include <map>
 #include <vector>
 
-#include "base/basictypes.h"
-#include "native_mate/scoped_persistent.h"
+#include "atom/common/id_weak_map.h"
 #include "native_mate/wrappable.h"
 
 namespace atom {
@@ -33,16 +31,8 @@ class IDWeakMap : public mate::Wrappable {
   bool Has(int32_t key) const;
   std::vector<int32_t> Keys() const;
   void Remove(int32_t key);
-  int GetNextID();
 
-  static void WeakCallback(
-      const v8::WeakCallbackData<v8::Object, IDWeakMap>& data);
-
-  int32_t next_id_;
-
-  typedef scoped_refptr<mate::RefCountedPersistent<v8::Object> >
-      RefCountedV8Object;
-  std::map<int32_t, RefCountedV8Object> map_;
+  atom::IDWeakMap map_;
 
   DISALLOW_COPY_AND_ASSIGN(IDWeakMap);
 };

atom/common/api/lib/id-weak-map.coffee

@@ -1,3 +0,0 @@
-IDWeakMap = process.atomBinding('id_weak_map').IDWeakMap
-
-module.exports = IDWeakMap

atom/common/id_weak_map.cc

@@ -0,0 +1,82 @@
+// Copyright (c) 2015 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/common/id_weak_map.h"
+
+#include <utility>
+
+#include "native_mate/converter.h"
+
+namespace atom {
+
+IDWeakMap::IDWeakMap() : next_id_(0) {
+}
+
+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);
+  map_.emplace(id, global);
+  return id;
+}
+
+v8::MaybeLocal<v8::Object> IDWeakMap::Get(v8::Isolate* isolate, int32_t id) {
+  auto iter = map_.find(id);
+  if (iter == map_.end())
+    return v8::MaybeLocal<v8::Object>();
+  else
+    return v8::Local<v8::Object>::New(isolate, *iter->second);
+}
+
+bool IDWeakMap::Has(int32_t id) const {
+  return map_.find(id) != map_.end();
+}
+
+std::vector<int32_t> IDWeakMap::Keys() const {
+  std::vector<int32_t> keys;
+  keys.reserve(map_.size());
+  for (const auto& iter : map_)
+    keys.emplace_back(iter.first);
+  return keys;
+}
+
+std::vector<v8::Local<v8::Object>> IDWeakMap::Values(v8::Isolate* isolate) {
+  std::vector<v8::Local<v8::Object>> keys;
+  keys.reserve(map_.size());
+  for (const auto& iter : map_)
+    keys.emplace_back(v8::Local<v8::Object>::New(isolate, *iter.second));
+  return keys;
+}
+
+void IDWeakMap::Remove(int32_t id) {
+  auto iter = map_.find(id);
+  if (iter == map_.end())
+    LOG(WARNING) << "Removing unexist object with ID " << id;
+  else
+    map_.erase(iter);
+}
+
+void IDWeakMap::Clear() {
+  map_.clear();
+}
+
+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

@@ -0,0 +1,61 @@
+// Copyright (c) 2015 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_COMMON_ID_WEAK_MAP_H_
+#define ATOM_COMMON_ID_WEAK_MAP_H_
+
+#include <unordered_map>
+#include <vector>
+
+#include "base/memory/linked_ptr.h"
+#include "v8/include/v8.h"
+
+namespace atom {
+
+// Like ES6's WeakMap, but the key is Integer and the value is Weak Pointer.
+class IDWeakMap {
+ public:
+  IDWeakMap();
+  ~IDWeakMap();
+
+  // Adds |object| to WeakMap and returns its allocated |id|.
+  int32_t Add(v8::Isolate* isolate, v8::Local<v8::Object> object);
+
+  // Gets the object from WeakMap by its |id|.
+  v8::MaybeLocal<v8::Object> Get(v8::Isolate* isolate, int32_t id);
+
+  // Whethere there is an object with |id| in this WeakMap.
+  bool Has(int32_t id) const;
+
+  // Returns IDs of all available objects.
+  std::vector<int32_t> Keys() const;
+
+  // Returns all objects.
+  std::vector<v8::Local<v8::Object>> Values(v8::Isolate* isolate);
+
+  // Remove object with |id| in the WeakMap.
+  void Remove(int32_t key);
+
+  // Clears the weak map.
+  void Clear();
+
+ private:
+  // 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_;
+
+  // Map of stored objects.
+  std::unordered_map<int32_t, linked_ptr<v8::Global<v8::Object>>> map_;
+
+  DISALLOW_COPY_AND_ASSIGN(IDWeakMap);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_COMMON_ID_WEAK_MAP_H_