Merge pull request #2611 from atom/pod-optimize

Optimize memory usage when using remote module

atom/browser/api/event_emitter.h

@@ -45,6 +45,8 @@ class EventEmitter : public Wrappable {
                       content::WebContents* sender,
                       IPC::Message* message,
                       const Args&... args) {
+    v8::Locker locker(isolate());
+    v8::HandleScope handle_scope(isolate());
     v8::Local<v8::Object> event = CreateJSEvent(isolate(), sender, message);
     return EmitWithEvent(name, event, args...);
   }

atom/browser/lib/objects-registry.coffee

@@ -1,82 +1,65 @@
 EventEmitter = require('events').EventEmitter
-IDWeakMap = process.atomBinding('id_weak_map').IDWeakMap
 v8Util = process.atomBinding 'v8_util'
 
-# Class to reference all objects.
-class ObjectsStore
-  @stores = {}
-
-  constructor: ->
-    @nextId = 0
-    @objects = []
-
-  getNextId: ->
-    ++@nextId
-
-  add: (obj) ->
-    id = @getNextId()
-    @objects[id] = obj
-    id
-
-  has: (id) ->
-    @objects[id]?
-
-  remove: (id) ->
-    throw new Error("Invalid key #{id} for ObjectsStore") unless @has id
-    delete @objects[id]
-
-  get: (id) ->
-    throw new Error("Invalid key #{id} for ObjectsStore") unless @has id
-    @objects[id]
-
-  @forRenderView: (key) ->
-    @stores[key] = new ObjectsStore unless @stores[key]?
-    @stores[key]
-
-  @releaseForRenderView: (key) ->
-    delete @stores[key]
-
 class ObjectsRegistry extends EventEmitter
   constructor: ->
     @setMaxListeners Number.MAX_VALUE
+    @nextId = 0
 
-    # Objects in weak map will be not referenced (so we won't leak memory), and
+    # Stores all objects by ref-counting.
-    # every object created in browser will have a unique id in weak map.
+    # (id) => {object, count}
-    @objectsWeakMap = new IDWeakMap
+    @storage = {}
-    @objectsWeakMap.add = (obj) ->
+
-      id = IDWeakMap::add.call this, obj
+    # Stores the IDs of objects referenced by WebContents.
-      v8Util.setHiddenValue obj, 'atomId', id
+    # (webContentsId) => {(id) => (count)}
-      id
+    @owners = {}
 
   # Register a new object, the object would be kept referenced until you release
   # it explicitly.
-  add: (key, obj) ->
+  add: (webContentsId, obj) ->
-    # Some native objects may already been added to objectsWeakMap, be care not
+    id = @saveToStorage obj
-    # to add it twice.
+    # Remember the owner.
-    @objectsWeakMap.add obj unless v8Util.getHiddenValue obj, 'atomId'
+    @owners[webContentsId] ?= {}
-    id = v8Util.getHiddenValue obj, 'atomId'
+    @owners[webContentsId][id] ?= 0
+    @owners[webContentsId][id]++
+    # Returns object's id
+    id
 
-    # Store and reference the object, then return the storeId which points to
+  # Get an object according to its ID.
-    # where the object is stored. The caller can later dereference the object
-    # with the storeId.
-    # We use a difference key because the same object can be referenced for
-    # multiple times by the same renderer view.
-    store = ObjectsStore.forRenderView key
-    storeId = store.add obj
-
-    [id, storeId]
-
-  # Get an object according to its id.
   get: (id) ->
-    @objectsWeakMap.get id
+    @storage[id]?.object
 
-  # Remove an object according to its storeId.
+  # Dereference an object according to its ID.
-  remove: (key, storeId) ->
+  remove: (webContentsId, id) ->
-    ObjectsStore.forRenderView(key).remove storeId
+    @dereference id, 1
+    # Also reduce the count in owner.
+    pointer = @owners[webContentsId]
+    --pointer[id]
+    delete pointer[id] if pointer[id] is 0
 
-  # Clear all references to objects from renderer view.
+  # Clear all references to objects refrenced by the WebContents.
-  clear: (key) ->
+  clear: (webContentsId) ->
-    @emit "clear-#{key}"
+    @emit "clear-#{webContentsId}"
-    ObjectsStore.releaseForRenderView key
+    return unless @owners[webContentsId]?
+    @dereference id, count for id, count of @owners[webContentsId]
+    delete @owners[webContentsId]
+
+  # Private: Saves the object into storage and assigns an ID for it.
+  saveToStorage: (object) ->
+    id = v8Util.getHiddenValue object, 'atomId'
+    unless id
+      id = ++@nextId
+      @storage[id] = {count: 0, object}
+      v8Util.setHiddenValue object, 'atomId', id
+    ++@storage[id].count
+    id
+
+  # Private: Dereference the object from store.
+  dereference: (id, count) ->
+    pointer = @storage[id]
+    pointer.count -= count
+    if pointer.count is 0
+      v8Util.deleteHiddenValue pointer.object, 'atomId'
+      delete @storage[id]
 
 module.exports = new ObjectsRegistry

atom/browser/lib/rpc-server.coffee

@@ -4,7 +4,7 @@ objectsRegistry = require './objects-registry.js'
 v8Util = process.atomBinding 'v8_util'
 
 # Convert a real value into meta data.
-valueToMeta = (sender, value) ->
+valueToMeta = (sender, value, optimizeSimpleObject=false) ->
   meta = type: typeof value
 
   meta.type = 'buffer' if Buffer.isBuffer value
@@ -12,6 +12,10 @@ valueToMeta = (sender, value) ->
   meta.type = 'array' if Array.isArray value
   meta.type = 'promise' if value? and value.constructor.name is 'Promise'
 
+  # Treat simple objects as value.
+  if optimizeSimpleObject and meta.type is 'object' and v8Util.getHiddenValue value, 'simple'
+    meta.type = 'value'
+
   # Treat the arguments object as array.
   meta.type = 'array' if meta.type is 'object' and value.callee? and value.length?
 
@@ -24,7 +28,7 @@ valueToMeta = (sender, value) ->
     # Reference the original value if it's an object, because when it's
     # passed to renderer we would assume the renderer keeps a reference of
     # it.
-    [meta.id, meta.storeId] = objectsRegistry.add sender.getId(), value
+    meta.id = objectsRegistry.add sender.getId(), value
 
     meta.members = []
     meta.members.push {name: prop, type: typeof field} for prop, field of value
@@ -80,11 +84,11 @@ unwrapArgs = (sender, args) ->
 callFunction = (event, func, caller, args) ->
   if v8Util.getHiddenValue(func, 'asynchronous') and typeof args[args.length - 1] isnt 'function'
     args.push (ret) ->
-      event.returnValue = valueToMeta event.sender, ret
+      event.returnValue = valueToMeta event.sender, ret, true
     func.apply caller, args
   else
     ret = func.apply caller, args
-    event.returnValue = valueToMeta event.sender, ret
+    event.returnValue = valueToMeta event.sender, ret, true
 
 # Send by BrowserWindow when its render view is deleted.
 process.on 'ATOM_BROWSER_RELEASE_RENDER_VIEW', (id) ->
@@ -170,8 +174,8 @@ ipc.on 'ATOM_BROWSER_MEMBER_GET', (event, id, name) ->
   catch e
     event.returnValue = errorToMeta e
 
-ipc.on 'ATOM_BROWSER_DEREFERENCE', (event, storeId) ->
+ipc.on 'ATOM_BROWSER_DEREFERENCE', (event, id) ->
-  objectsRegistry.remove event.sender.getId(), storeId
+  objectsRegistry.remove event.sender.getId(), id
 
 ipc.on 'ATOM_BROWSER_GUEST_WEB_CONTENTS', (event, guestInstanceId) ->
   try

atom/common/api/atom_api_id_weak_map.cc

@@ -1,80 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "atom/common/api/atom_api_id_weak_map.h"
-
-#include "native_mate/constructor.h"
-#include "native_mate/object_template_builder.h"
-
-#include "atom/common/node_includes.h"
-
-namespace atom {
-
-namespace api {
-
-IDWeakMap::IDWeakMap() {
-}
-
-IDWeakMap::~IDWeakMap() {
-}
-
-int32_t IDWeakMap::Add(v8::Isolate* isolate, v8::Local<v8::Object> object) {
-  return map_.Add(isolate, object);
-}
-
-v8::Local<v8::Value> IDWeakMap::Get(v8::Isolate* isolate, int32_t 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();
-  }
-}
-
-bool IDWeakMap::Has(int32_t key) const {
-  return map_.Has(key);
-}
-
-std::vector<int32_t> IDWeakMap::Keys() const {
-  return map_.Keys();
-}
-
-void IDWeakMap::Remove(int32_t key) {
-  map_.Remove(key);
-}
-
-// static
-void IDWeakMap::BuildPrototype(v8::Isolate* isolate,
-                               v8::Local<v8::ObjectTemplate> prototype) {
-  mate::ObjectTemplateBuilder(isolate, prototype)
-      .SetMethod("add", &IDWeakMap::Add)
-      .SetMethod("get", &IDWeakMap::Get)
-      .SetMethod("has", &IDWeakMap::Has)
-      .SetMethod("keys", &IDWeakMap::Keys)
-      .SetMethod("remove", &IDWeakMap::Remove);
-}
-
-}  // namespace api
-
-}  // namespace atom
-
-
-namespace {
-
-void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
-                v8::Local<v8::Context> context, void* priv) {
-  using atom::api::IDWeakMap;
-  v8::Isolate* isolate = context->GetIsolate();
-  v8::Local<v8::Function> constructor = mate::CreateConstructor<IDWeakMap>(
-      isolate,
-      "IDWeakMap",
-      base::Bind(&mate::NewOperatorFactory<IDWeakMap>));
-  exports->Set(mate::StringToSymbol(isolate, "IDWeakMap"), constructor);
-}
-
-}  // namespace
-
-NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_common_id_weak_map, Initialize)

atom/common/api/atom_api_id_weak_map.h

@@ -1,44 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc.
-// Copyright (c) 2012 Intel Corp. All rights reserved.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#ifndef ATOM_COMMON_API_ATOM_API_ID_WEAK_MAP_H_
-#define ATOM_COMMON_API_ATOM_API_ID_WEAK_MAP_H_
-
-#include <vector>
-
-#include "atom/common/id_weak_map.h"
-#include "native_mate/wrappable.h"
-
-namespace atom {
-
-namespace api {
-
-// Like ES6's WeakMap, but the key is Integer and the value is Weak Pointer.
-class IDWeakMap : public mate::Wrappable {
- public:
-  IDWeakMap();
-
-  static void BuildPrototype(v8::Isolate* isolate,
-                             v8::Local<v8::ObjectTemplate> prototype);
-
- private:
-  virtual ~IDWeakMap();
-
-  int32_t Add(v8::Isolate* isolate, v8::Local<v8::Object> object);
-  v8::Local<v8::Value> Get(v8::Isolate* isolate, int32_t key);
-  bool Has(int32_t key) const;
-  std::vector<int32_t> Keys() const;
-  void Remove(int32_t key);
-
-  atom::IDWeakMap map_;
-
-  DISALLOW_COPY_AND_ASSIGN(IDWeakMap);
-};
-
-}  // namespace api
-
-}  // namespace atom
-
-#endif  // ATOM_COMMON_API_ATOM_API_ID_WEAK_MAP_H_

atom/common/api/atom_api_v8_util.cc

@@ -28,6 +28,11 @@ void SetHiddenValue(v8::Local<v8::Object> object,
   object->SetHiddenValue(key, value);
 }
 
+void DeleteHiddenValue(v8::Local<v8::Object> object,
+                       v8::Local<v8::String> key) {
+  object->DeleteHiddenValue(key);
+}
+
 int32_t GetObjectHash(v8::Local<v8::Object> object) {
   return object->GetIdentityHash();
 }
@@ -48,6 +53,7 @@ void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
   dict.SetMethod("createObjectWithName", &CreateObjectWithName);
   dict.SetMethod("getHiddenValue", &GetHiddenValue);
   dict.SetMethod("setHiddenValue", &SetHiddenValue);
+  dict.SetMethod("deleteHiddenValue", &DeleteHiddenValue);
   dict.SetMethod("getObjectHash", &GetObjectHash);
   dict.SetMethod("setDestructor", &SetDestructor);
   dict.SetMethod("takeHeapSnapshot", &TakeHeapSnapshot);

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) {
+                               v8::Local<v8::Function> destructor) {
-  target->SetHiddenValue(MATE_STRING_NEW(isolate, "destructor"), destructor);
+  new ObjectLifeMonitor(isolate, target, destructor);
-
-  ObjectLifeMonitor* olm = new ObjectLifeMonitor();
-  olm->handle_.reset(isolate, target);
-  olm->handle_.SetWeak(olm, WeakCallback);
 }
 
-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(
+void ObjectLifeMonitor::OnObjectGC(
-    const v8::WeakCallbackData<v8::Object, ObjectLifeMonitor>& data) {
+    const v8::WeakCallbackInfo<ObjectLifeMonitor>& data) {
-  // destructor.call(object, object);
+  // Usually FirstWeakCallback should do nothing other than reset |object_|
-  v8::Local<v8::Object> obj = data.GetValue();
+  // and then set a second weak callback to run later. We can sidestep that,
-  v8::Local<v8::Function>::Cast(obj->GetHiddenValue(
+  // because posting a task to the current message loop is all but free - but
-      MATE_STRING_NEW(data.GetIsolate(), "destructor")))->Call(obj, 0, NULL);
+  // DO NOT add any more work to this method. The only acceptable place to add
-  delete data.GetParameter();
+  // 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(
+  static void OnObjectGC(const v8::WeakCallbackInfo<ObjectLifeMonitor>& data);
-      const v8::WeakCallbackData<v8::Object, 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,22 @@
 
 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();
+  key->map->Remove(key->id);
+  delete key;
+}
+
+}  // namespace
+
 IDWeakMap::IDWeakMap() : next_id_(0) {
 }
 
@@ -18,11 +34,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 +85,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_;
 

atom/common/native_mate_converters/gfx_converter.cc

@@ -14,7 +14,8 @@ namespace mate {
 
 v8::Local<v8::Value> Converter<gfx::Point>::ToV8(v8::Isolate* isolate,
                                                   const gfx::Point& val) {
-  mate::Dictionary dict(isolate, v8::Object::New(isolate));
+  mate::Dictionary dict = mate::Dictionary::CreateEmpty(isolate);
+  dict.SetHidden("simple", true);
   dict.Set("x", val.x());
   dict.Set("y", val.y());
   return dict.GetHandle();
@@ -35,7 +36,8 @@ bool Converter<gfx::Point>::FromV8(v8::Isolate* isolate,
 
 v8::Local<v8::Value> Converter<gfx::Size>::ToV8(v8::Isolate* isolate,
                                                   const gfx::Size& val) {
-  mate::Dictionary dict(isolate, v8::Object::New(isolate));
+  mate::Dictionary dict = mate::Dictionary::CreateEmpty(isolate);
+  dict.SetHidden("simple", true);
   dict.Set("width", val.width());
   dict.Set("height", val.height());
   return dict.GetHandle();
@@ -56,7 +58,8 @@ bool Converter<gfx::Size>::FromV8(v8::Isolate* isolate,
 
 v8::Local<v8::Value> Converter<gfx::Rect>::ToV8(v8::Isolate* isolate,
                                                  const gfx::Rect& val) {
-  mate::Dictionary dict(isolate, v8::Object::New(isolate));
+  mate::Dictionary dict = mate::Dictionary::CreateEmpty(isolate);
+  dict.SetHidden("simple", true);
   dict.Set("x", val.x());
   dict.Set("y", val.y());
   dict.Set("width", val.width());
@@ -95,7 +98,8 @@ struct Converter<gfx::Display::TouchSupport> {
 
 v8::Local<v8::Value> Converter<gfx::Display>::ToV8(v8::Isolate* isolate,
                                                     const gfx::Display& val) {
-  mate::Dictionary dict(isolate, v8::Object::New(isolate));
+  mate::Dictionary dict = mate::Dictionary::CreateEmpty(isolate);
+  dict.SetHidden("simple", true);
   dict.Set("id", val.id());
   dict.Set("bounds", val.bounds());
   dict.Set("workArea", val.work_area());

atom/common/native_mate_converters/v8_value_converter.cc

@@ -11,6 +11,7 @@
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
+#include "native_mate/dictionary.h"
 #include "vendor/node/src/node_buffer.h"
 
 namespace atom {
@@ -179,7 +180,8 @@ v8::Local<v8::Value> V8ValueConverter::ToV8Array(
 
 v8::Local<v8::Value> V8ValueConverter::ToV8Object(
     v8::Isolate* isolate, const base::DictionaryValue* val) const {
-  v8::Local<v8::Object> result(v8::Object::New(isolate));
+  mate::Dictionary result = mate::Dictionary::CreateEmpty(isolate);
+  result.SetHidden("simple", true);
 
   for (base::DictionaryValue::Iterator iter(*val);
        !iter.IsAtEnd(); iter.Advance()) {
@@ -188,17 +190,14 @@ v8::Local<v8::Value> V8ValueConverter::ToV8Object(
     CHECK(!child_v8.IsEmpty());
 
     v8::TryCatch try_catch;
-    result->Set(
+    result.Set(key, child_v8);
-        v8::String::NewFromUtf8(isolate, key.c_str(), v8::String::kNormalString,
-                                key.length()),
-        child_v8);
     if (try_catch.HasCaught()) {
       LOG(ERROR) << "Setter for property " << key.c_str() << " threw an "
                  << "exception.";
     }
   }
 
-  return result;
+  return result.GetHandle();
 }
 
 base::Value* V8ValueConverter::FromV8ValueImpl(

atom/common/node_bindings.cc

@@ -47,7 +47,6 @@ REFERENCE_MODULE(atom_browser_window);
 REFERENCE_MODULE(atom_common_asar);
 REFERENCE_MODULE(atom_common_clipboard);
 REFERENCE_MODULE(atom_common_crash_reporter);
-REFERENCE_MODULE(atom_common_id_weak_map);
 REFERENCE_MODULE(atom_common_native_image);
 REFERENCE_MODULE(atom_common_screen);
 REFERENCE_MODULE(atom_common_shell);

atom/renderer/api/lib/remote.coffee

@@ -102,7 +102,7 @@ metaToValue = (meta) ->
       # Track delegate object's life time, and tell the browser to clean up
       # when the object is GCed.
       v8Util.setDestructor ret, ->
-        ipc.send 'ATOM_BROWSER_DEREFERENCE', meta.storeId
+        ipc.send 'ATOM_BROWSER_DEREFERENCE', meta.id
 
       # Remember object's id.
       v8Util.setHiddenValue ret, 'atomId', meta.id

filenames.gypi

@@ -235,8 +235,6 @@
       'atom/common/api/atom_api_asar.cc',
       'atom/common/api/atom_api_clipboard.cc',
       'atom/common/api/atom_api_crash_reporter.cc',
-      'atom/common/api/atom_api_id_weak_map.cc',
-      'atom/common/api/atom_api_id_weak_map.h',
       'atom/common/api/atom_api_native_image.cc',
       'atom/common/api/atom_api_native_image.h',
       'atom/common/api/atom_api_native_image_mac.mm',

spec/chromium-spec.coffee

@@ -8,7 +8,7 @@ remote = require 'remote'
 describe 'chromium feature', ->
   fixtures = path.resolve __dirname, 'fixtures'
 
-  describe 'heap snapshot', ->
+  xdescribe 'heap snapshot', ->
     it 'does not crash', ->
       process.atomBinding('v8_util').takeHeapSnapshot()
 

vendor/native_mate

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