Don't abuse timers (#1108)

Previously, the object inspector would schedule an infinite timer
that fires every 300ms to update the current object (it actually
fires even where there isn't a current object to update). This is
extremely inefficient, and it causes a lot of extra work in big
apps, since the timer starts a runloop which results in a full
top-down revalidation. The more appropriate thing to do is tap
into the runloop callbacks, since as far as Ember is concerned,
if there are no runloops, there are no observable changes.

Author: chancancode

ember_debug/object-inspector.js

@@ -1,15 +1,17 @@
 import PortMixin from 'ember-debug/mixins/port-mixin';
-import { compareVersion } from 'ember-debug/utils/version';
+import bound from 'ember-debug/utils/bound-method';
 import { isComputed, isDescriptor, getDescriptorFor } from 'ember-debug/utils/type-check';
+import { compareVersion } from 'ember-debug/utils/version';
 import { typeOf } from './utils/type-check';
 
 const Ember = window.Ember;
 const {
   Object: EmberObject, inspect: emberInspect, meta: emberMeta,
   computed, get, set, guidFor, isNone,
-  cacheFor, VERSION
+  cacheFor, VERSION, run,
 } = Ember;
 const { oneWay } = computed;
+const { backburner, join } = run;
 
 let glimmer;
 let metal;
@@ -266,21 +268,20 @@ export default EmberObject.extend(PortMixin, {
         });
       });
     }
-    // workaround for tests, since calling any runloop inside runloop will prevent any `settled` to be called
-    setTimeout(() => Ember.run.next(this, this.updateCurrentObject), 300);
   },
 
   init() {
     this._super();
     this.set('sentObjects', {});
-    Ember.run.next(this, this.updateCurrentObject);
+    backburner.on('end', bound(this, this.updateCurrentObject));
   },
 
   willDestroy() {
     this._super();
     for (let objectId in this.sentObjects) {
       this.releaseObject(objectId);
     }
+    backburner.off('end', bound(this, this.updateCurrentObject));
   },
 
   sentObjects: {},
@@ -391,7 +392,7 @@ export default EmberObject.extend(PortMixin, {
 
   saveProperty(objectId, prop, val) {
     let object = this.sentObjects[objectId];
-    set(object, prop, val);
+    join(() => set(object, prop, val));
   },
 
   sendToConsole(objectId, prop) {
@@ -489,7 +490,6 @@ export default EmberObject.extend(PortMixin, {
     if (meta._debugReferences === 0) {
       this.dropObject(guid);
     }
-
   },
 
   dropObject(objectId) {

ember_debug/utils/bound-method.js

@@ -0,0 +1,44 @@
+const ENTRIES = new WeakMap();
+
+function entriesFor(obj) {
+  let entries = ENTRIES.get(obj);
+
+  if (entries === undefined) {
+    entries = new WeakMap();
+    ENTRIES.set(obj, entries);
+  }
+
+  return entries;
+}
+
+/**
+ * Return `method.bind(obj)` or `obj[method].bind(obj)`. When called multiple
+ * times, the same bound function will be returned.
+ *
+ * @param {Object} obj
+ * @param {String|Symbol|Function} method
+ * @return {Function}
+ */
+export default function bound(obj, method) {
+  let func;
+
+  if (typeof method === 'function') {
+    func = method;
+  } else {
+    func = obj[method];
+
+    if (typeof func !== 'function') {
+      throw new TypeError(`${obj}[${method}] is not a function (was ${func})`);
+    }
+  }
+
+  let entries = entriesFor(obj);
+  let bound = entries.get(func);
+
+  if (bound === undefined) {
+    bound = func.bind(obj);
+    entries.set(func, bound);
+  }
+
+  return bound;
+}