--- a/toolkit/devtools/server/actors/memory.js
+++ b/toolkit/devtools/server/actors/memory.js
@@ -57,31 +57,49 @@ types.addDictType("AllocationsRecordingO
  * An actor that returns memory usage data for its parent actor's window.
  * A tab-scoped instance of this actor will measure the memory footprint of its
  * parent tab. A global-scoped instance however, will measure the memory
  * footprint of the chrome window referenced by the root actor.
  */
 let MemoryActor = protocol.ActorClass({
   typeName: "memory",
 
+  /**
+   * The set of unsolicited events the MemoryActor emits that will be sent over
+   * the RDP (by protocol.js).
+   */
+  events: {
+    // Same format as the data passed to the
+    // `Debugger.Memory.prototype.onGarbageCollection` hook. See
+    // `js/src/doc/Debugger/Debugger.Memory.md` for documentation.
+    "garbage-collection": {
+      type: "garbage-collection",
+      data: Arg(0, "json"),
+    },
+  },
+
   get dbg() {
     if (!this._dbg) {
       this._dbg = this.parent.makeDebugger();
     }
     return this._dbg;
   },
 
   initialize: function(conn, parent, frameCache = new StackFrameCache()) {
     protocol.Actor.prototype.initialize.call(this, conn);
     this.parent = parent;
     this._mgr = Cc["@mozilla.org/memory-reporter-manager;1"]
                   .getService(Ci.nsIMemoryReporterManager);
     this.state = "detached";
     this._dbg = null;
     this._frameCache = frameCache;
+
+    this._onGarbageCollection = data =>
+      events.emit(this, "garbage-collection", data);
+
     this._onWindowReady = this._onWindowReady.bind(this);
 
     events.on(this.parent, "window-ready", this._onWindowReady);
   },
 
   destroy: function() {
     events.off(this.parent, "window-ready", this._onWindowReady);
 
@@ -89,19 +107,24 @@ let MemoryActor = protocol.ActorClass({
     if (this.state === "attached") {
       this.detach();
     }
     protocol.Actor.prototype.destroy.call(this);
   },
 
   /**
    * Attach to this MemoryActor.
+   *
+   * This attaches the MemoryActor's Debugger instance so that you can start
+   * recording allocations or take a census of the heap. In addition, the
+   * MemoryActor will start emitting GC events.
    */
   attach: method(expectState("detached", function() {
     this.dbg.addDebuggees();
+    this.dbg.memory.onGarbageCollection = this._onGarbageCollection;
     this.state = "attached";
   },
   `attaching to the debugger`), {
     request: {},
     response: {
       type: "attached"
     }
   }),