Upgrade Event Listeners redux backend

jasonLaster · jasonLaster · commit fe5e7c521900 · 2016-11-29T17:51:59.000-05:00
diff --git a/packages/devtools-client-adapters/src/firefox/commands.js b/packages/devtools-client-adapters/src/firefox/commands.js
@@ -144,7 +144,22 @@ function disablePrettyPrint(sourceId) {
   return sourceClient.disablePrettyPrint();
 }
 
+function interrupt() {
+  return threadClient.interrupt();
+}
+
+function eventListeners() {
+  return threadClient.eventListeners();
+}
+
+function pauseGrip(func) {
+  return threadClient.pauseGrip(func);
+}
+
 const clientCommands = {
+  interrupt,
+  eventListeners,
+  pauseGrip,
   resume,
   stepIn,
   stepOut,
diff --git a/packages/devtools-client-adapters/src/firefox/events.js b/packages/devtools-client-adapters/src/firefox/events.js
@@ -1,4 +1,5 @@
 const { createFrame, createSource } = require("./create");
+const { isEnabled } = require("devtools-config");
 
 const CALL_STACK_PAGE_SIZE = 1000;
 
@@ -36,6 +37,10 @@ function resumed(_, packet) {
 
 function newSource(_, { source }) {
   actions.newSource(createSource(source));
+
+  if (isEnabled("eventListeners")) {
+    actions.fetchEventListeners();
+  }
 }
 
 const clientEvents = {
diff --git a/src/actions/event-listeners.js b/src/actions/event-listeners.js
@@ -10,24 +10,51 @@
  */
 
 const constants = require("../constants");
-const { asPaused } = require("../utils/utils");
 const { reportException } = require("../utils/DevToolsUtils");
-const { Task } = require("../utils/task");
+const { getPause } = require("../selectors");
 
 // delay is in ms
 const FETCH_EVENT_LISTENERS_DELAY = 200;
+let fetchListenersTimerID;
+
+/**
+ * @memberof utils/utils
+ * @static
+ */
+async function asPaused(state: any, client: any, func: any) {
+  if (!getPause(state)) {
+    await client.interrupt();
+    let result;
+
+    try {
+      result = await func(client);
+    } catch (e) {
+      // Try to put the debugger back in a working state by resuming
+      // it
+      await client.resume();
+      throw e;
+    }
+
+    await client.resume();
+    return result;
+  }
+
+  return func(client);
+}
 
 /**
  * @memberof actions/event-listeners
  * @static
  */
 function fetchEventListeners() {
-  return (dispatch, getState) => {
+  return ({ dispatch, getState, client }) => {
     // Make sure we"re not sending a batch of closely repeated requests.
     // This can easily happen whenever new sources are fetched.
-    setNamedTimeout(
-        "event-listeners-fetch",
-        FETCH_EVENT_LISTENERS_DELAY,
+    if (fetchListenersTimerID) {
+      clearTimeout(fetchListenersTimerID);
+    }
+
+    fetchListenersTimerID = setTimeout(
         () => {
           // In case there is still a request of listeners going on (it
           // takes several RDP round trips right now), make sure we wait
@@ -49,23 +76,19 @@ function fetchEventListeners() {
             status: "begin"
           });
 
-          asPaused(gThreadClient, _getListeners).then(listeners => {
-            // Notify that event listeners were fetched and shown in the view,
-            // and callback to resume the active thread if necessary.
-            window.emit(EVENTS.EVENT_LISTENERS_FETCHED);
-
+          asPaused(getState(), client, _getEventListeners).then(listeners => {
             dispatch({
               type: constants.FETCH_EVENT_LISTENERS,
               status: "done",
               listeners: listeners
             });
           });
-        });
+        }, FETCH_EVENT_LISTENERS_DELAY);
   };
 }
 
-const _getListeners = Task.async(function* () {
-  const response = yield gThreadClient.eventListeners();
+async function _getEventListeners(threadClient) {
+  const response = await threadClient.eventListeners();
 
   // Make sure all the listeners are sorted by the event type, since
   // they"re not guaranteed to be clustered together.
@@ -79,7 +102,10 @@ const _getListeners = Task.async(function* () {
     if (fetchedDefinitions.has(listener.function.actor)) {
       definitionSite = fetchedDefinitions.get(listener.function.actor);
     } else if (listener.function.class == "Function") {
-      definitionSite = yield _getDefinitionSite(listener.function);
+      definitionSite = await _getDefinitionSite(
+        threadClient,
+        listener.function
+      );
       if (!definitionSite) {
         // We don"t know where this listener comes from so don"t show it in
         // the UI as breaking on it doesn"t work (bug 942899).
@@ -94,22 +120,22 @@ const _getListeners = Task.async(function* () {
   fetchedDefinitions.clear();
 
   return listeners;
-});
+}
 
-const _getDefinitionSite = Task.async(function* (func) {
-  const grip = gThreadClient.pauseGrip(func);
+async function _getDefinitionSite(threadClient, func) {
+  const grip = threadClient.pauseGrip(func);
   let response;
 
   try {
-    response = yield grip.getDefinitionSite();
+    response = await grip.getDefinitionSite();
   } catch (e) {
     // Don't make this error fatal, it would break the entire events pane.
     reportException("_getDefinitionSite", e);
     return null;
   }
 
   return response.source.url;
-});
+}
 
 /**
  * @memberof actions/event-listeners
diff --git a/src/reducers/event-listeners.js b/src/reducers/event-listeners.js
@@ -14,15 +14,14 @@ function update(state = initialState, action, emit) {
   switch (action.type) {
     case constants.UPDATE_EVENT_BREAKPOINTS:
       state.activeEventNames = action.eventNames;
-      emit("activeEventNames", state.activeEventNames);
+      // emit("activeEventNames", state.activeEventNames);
       break;
     case constants.FETCH_EVENT_LISTENERS:
       if (action.status === "begin") {
         state.fetchingListeners = true;
       } else if (action.status === "done") {
         state.fetchingListeners = false;
         state.listeners = action.listeners;
-        emit("event-listeners", state.listeners);
       }
       break;
     case constants.NAVIGATE:
@@ -32,4 +31,11 @@ function update(state = initialState, action, emit) {
   return state;
 }
 
-module.exports = update;
+function getEventListeners(state) {
+  return state.listeners;
+}
+
+module.exports = {
+  update,
+  getEventListeners
+};
diff --git a/src/reducers/index.js b/src/reducers/index.js
@@ -10,7 +10,7 @@ const pause = require("./pause");
 const ui = require("./ui");
 
 module.exports = {
-  eventListeners,
+  eventListeners: eventListeners.update,
   sources: sources.update,
   breakpoints: breakpoints.update,
   pause: pause.update,
diff --git a/src/selectors.js b/src/selectors.js
@@ -3,6 +3,7 @@
 const sources = require("./reducers/sources");
 const pause = require("./reducers/pause");
 const breakpoints = require("./reducers/breakpoints");
+const eventListeners = require("./reducers/event-listeners");
 const ui = require("./reducers/ui");
 
 /**
@@ -36,5 +37,7 @@ module.exports = {
   getFrames: pause.getFrames,
   getSelectedFrame: pause.getSelectedFrame,
 
+  getEventListeners: eventListeners.getEventListeners,
+
   getFileSearchState: ui.getFileSearchState
 };
diff --git a/src/utils/utils.js b/src/utils/utils.js
@@ -10,34 +10,6 @@
  * @module utils/utils
  */
 
-const co = require("co");
-
-/**
- * @memberof utils/utils
- * @static
- */
-function asPaused(client: any, func: any) {
-  if (client.state != "paused") {
-    return co(function* () {
-      yield client.interrupt();
-      let result;
-
-      try {
-        result = yield func();
-      } catch (e) {
-        // Try to put the debugger back in a working state by resuming
-        // it
-        yield client.resume();
-        throw e;
-      }
-
-      yield client.resume();
-      return result;
-    });
-  }
-  return func();
-}
-
 /**
  * @memberof utils/utils
  * @static
@@ -225,7 +197,6 @@ function throttle(func: any, ms: number) {
 }
 
 module.exports = {
-  asPaused,
   handleError,
   promisify,
   truncateStr,
