diagnostics_channel: split active/inactive prototype for StorageChannel

Author: Stephen Belanger

lib/_http_server.js

@@ -1010,8 +1010,8 @@ function parserOnIncoming(server, socket, state, req, keepAlive) {
     });
   }
 
-  if (storageChannel._enter.hasSubscribers) {
-    storageChannel._enter.publish({
+  if (storageChannel.hasSubscribers) {
+    storageChannel._enter({
       request: req,
       response: res,
       socket,
@@ -1077,8 +1077,8 @@ function parserOnIncoming(server, socket, state, req, keepAlive) {
     server.emit('request', req, res);
   }
 
-  if (storageChannel._exit.hasSubscribers) {
-    storageChannel._exit.publish();
+  if (storageChannel.hasSubscribers) {
+    storageChannel._exit();
   }
 
   return 0;  // No special treatment.

lib/diagnostics_channel.js

@@ -3,6 +3,7 @@
 const {
   ArrayPrototypeIndexOf,
   ArrayPrototypePush,
+  ArrayPrototypeSome,
   ArrayPrototypeSplice,
   ObjectCreate,
   ObjectGetPrototypeOf,
@@ -160,43 +161,100 @@ class StoreBinding {
 
 // TODO(qard): figure out if putting everything on the channel has the same GC
 // issue as channel.subscribe(...) did.
-class StorageChannel {
-  constructor(name) {
-    this._enter = channel(`${name}.enter-store`);
-    this._exit = channel(`${name}.exit-store`);
-    this.kBinding = Symbol('binding');
+class ActiveStorageChannel {
+  get hasSubscribers () {
+    return true;
   }
 
-  isBoundToStore (store) {
-    return !!store[this.kBinding];
+  isBoundToStore(store) {
+    return ArrayPrototypeSome(this.bindings, v => v.store === store);
   }
 
   bindStore(store, build) {
-    if (this.isBoundToStore(store)) return;
-    const binding = new StoreBinding(store, build);
-    store[this.kBinding] = binding;
-    this._enter.subscribe(binding.onEnter);
-    this._exit.subscribe(binding.onExit);
+    if (this.isBoundToStore(store)) return false;
+    ArrayPrototypePush(this.bindings, new StoreBinding(store, build));
+    return true;
   }
 
   unbindStore(store) {
-    if (!this.isBoundToStore(store)) return;
-    const binding = store[this.kBinding];
-    this._enter.unsubscribe(binding.onEnter);
-    this._exit.unsubscribe(binding.onExit);
-    delete store[this.kBinding];
+    if (!this.isBoundToStore(store)) return false;
+
+    let found = false;
+    for (let index = 0; index < this.bindings.length; index++) {
+      if (this.bindings[index].store === store) {
+        ArrayPrototypeSplice(this.bindings, index, 1);
+        found = true;
+        break;
+      }
+    }
+
+    if (!this.bindings.length) {
+      ObjectSetPrototypeOf(this, StorageChannel.prototype);
+      this.bindings = undefined;
+    }
+
+    return found;
+  }
+
+  _enter(data) {
+    for (const binding of this.bindings) {
+      binding.onEnter(data);
+    }
+  }
+
+  _exit() {
+    for (const binding of this.bindings) {
+      binding.onExit();
+    }
   }
 
   run(data, fn) {
-    this._enter.publish(data);
+    this._enter(data);
     try {
       return fn();
     } finally {
-      this._exit.publish();
+      this._exit();
     }
   }
 }
 
+class StorageChannel {
+  constructor() {
+    this.bindings = undefined;
+  }
+
+  static [SymbolHasInstance](instance) {
+    const prototype = ObjectGetPrototypeOf(instance);
+    return prototype === StorageChannel.prototype ||
+      prototype === ActiveStorageChannel.prototype;
+  }
+
+  get hasSubscribers() {
+    return false;
+  }
+
+  isBoundToStore(_) {
+    return false;
+  }
+
+  bindStore(store, build) {
+    ObjectSetPrototypeOf(this, ActiveStorageChannel.prototype);
+    this.bindings = [];
+    return this.bindStore(store, build);
+  }
+
+  unbindStore(_) {
+    return false;
+  }
+
+  _enter(_) {}
+  _exit() {}
+
+  run(_, fn) {
+    return fn();
+  }
+}
+
 const storageChannels = ObjectCreate(null);
 
 function storageChannel(name) {