From 5f8de423f190bbb79a62f804151bc24824fa32d8 Mon Sep 17 00:00:00 2001 From: "Matt A. Tobin" Date: Fri, 2 Feb 2018 04:16:08 -0500 Subject: Add m-esr52 at 52.6.0 --- .../debugger/content/reducers/async-requests.js | 31 +++++ .../debugger/content/reducers/breakpoints.js | 153 +++++++++++++++++++++ .../debugger/content/reducers/event-listeners.js | 37 +++++ devtools/client/debugger/content/reducers/index.js | 16 +++ .../client/debugger/content/reducers/moz.build | 12 ++ .../client/debugger/content/reducers/sources.js | 128 +++++++++++++++++ 6 files changed, 377 insertions(+) create mode 100644 devtools/client/debugger/content/reducers/async-requests.js create mode 100644 devtools/client/debugger/content/reducers/breakpoints.js create mode 100644 devtools/client/debugger/content/reducers/event-listeners.js create mode 100644 devtools/client/debugger/content/reducers/index.js create mode 100644 devtools/client/debugger/content/reducers/moz.build create mode 100644 devtools/client/debugger/content/reducers/sources.js (limited to 'devtools/client/debugger/content/reducers') diff --git a/devtools/client/debugger/content/reducers/async-requests.js b/devtools/client/debugger/content/reducers/async-requests.js new file mode 100644 index 000000000..206e1cf60 --- /dev/null +++ b/devtools/client/debugger/content/reducers/async-requests.js @@ -0,0 +1,31 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ +"use strict"; + +const constants = require("../constants"); +const initialState = []; + +function update(state = initialState, action, emitChange) { + const { seqId } = action; + + if (action.type === constants.UNLOAD) { + return initialState; + } + else if (seqId) { + let newState; + if (action.status === "start") { + newState = [...state, seqId]; + } + else if (action.status === "error" || action.status === "done") { + newState = state.filter(id => id !== seqId); + } + + emitChange("open-requests", newState); + return newState; + } + + return state; +} + +module.exports = update; diff --git a/devtools/client/debugger/content/reducers/breakpoints.js b/devtools/client/debugger/content/reducers/breakpoints.js new file mode 100644 index 000000000..7e42098e8 --- /dev/null +++ b/devtools/client/debugger/content/reducers/breakpoints.js @@ -0,0 +1,153 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ +"use strict"; + +const constants = require("../constants"); +const Immutable = require("devtools/client/shared/vendor/seamless-immutable"); +const { mergeIn, setIn, deleteIn } = require("../utils"); +const { makeLocationId } = require("../queries"); + +const initialState = Immutable({ + breakpoints: {} +}); + +// Return the first argument that is a string, or null if nothing is a +// string. +function firstString(...args) { + for (var arg of args) { + if (typeof arg === "string") { + return arg; + } + } + return null; +} + +function update(state = initialState, action, emitChange) { + switch (action.type) { + case constants.ADD_BREAKPOINT: { + const id = makeLocationId(action.breakpoint.location); + + if (action.status === "start") { + const existingBp = state.breakpoints[id]; + const bp = existingBp || Immutable(action.breakpoint); + + state = setIn(state, ["breakpoints", id], bp.merge({ + disabled: false, + loading: true, + // We want to do an OR here, but we can't because we need + // empty strings to be truthy, i.e. an empty string is a valid + // condition. + condition: firstString(action.condition, bp.condition) + })); + + emitChange(existingBp ? "breakpoint-enabled" : "breakpoint-added", + state.breakpoints[id]); + return state; + } + else if (action.status === "done") { + const { actor, text } = action.value; + let { actualLocation } = action.value; + + // If the breakpoint moved, update the map + if (actualLocation) { + // XXX Bug 1227417: The `setBreakpoint` RDP request rdp + // request returns an `actualLocation` field that doesn't + // conform to the regular { actor, line } location shape, but + // it has a `source` field. We should fix that. + actualLocation = { actor: actualLocation.source.actor, + line: actualLocation.line }; + + state = deleteIn(state, ["breakpoints", id]); + + const movedId = makeLocationId(actualLocation); + const currentBp = state.breakpoints[movedId] || Immutable(action.breakpoint); + const prevLocation = action.breakpoint.location; + const newBp = currentBp.merge({ location: actualLocation }); + state = setIn(state, ["breakpoints", movedId], newBp); + + emitChange("breakpoint-moved", { + breakpoint: newBp, + prevLocation: prevLocation + }); + } + + const finalLocation = ( + actualLocation ? actualLocation : action.breakpoint.location + ); + const finalLocationId = makeLocationId(finalLocation); + state = mergeIn(state, ["breakpoints", finalLocationId], { + disabled: false, + loading: false, + actor: actor, + text: text + }); + emitChange("breakpoint-updated", state.breakpoints[finalLocationId]); + return state; + } + else if (action.status === "error") { + // Remove the optimistic update + emitChange("breakpoint-removed", state.breakpoints[id]); + return deleteIn(state, ["breakpoints", id]); + } + break; + } + + case constants.REMOVE_BREAKPOINT: { + if (action.status === "done") { + const id = makeLocationId(action.breakpoint.location); + const bp = state.breakpoints[id]; + + if (action.disabled) { + state = mergeIn(state, ["breakpoints", id], + { loading: false, disabled: true }); + emitChange("breakpoint-disabled", state.breakpoints[id]); + return state; + } + + state = deleteIn(state, ["breakpoints", id]); + emitChange("breakpoint-removed", bp); + return state; + } + break; + } + + case constants.SET_BREAKPOINT_CONDITION: { + const id = makeLocationId(action.breakpoint.location); + const bp = state.breakpoints[id]; + emitChange("breakpoint-condition-updated", bp); + + if (!action.status) { + // No status means that it wasn't a remote request. Just update + // the condition locally. + return mergeIn(state, ["breakpoints", id], { + condition: action.condition + }); + } + else if (action.status === "start") { + return mergeIn(state, ["breakpoints", id], { + loading: true, + condition: action.condition + }); + } + else if (action.status === "done") { + return mergeIn(state, ["breakpoints", id], { + loading: false, + condition: action.condition, + // Setting a condition creates a new breakpoint client as of + // now, so we need to update the actor + actor: action.value.actor + }); + } + else if (action.status === "error") { + emitChange("breakpoint-removed", bp); + return deleteIn(state, ["breakpoints", id]); + } + + break; + }} + + return state; +} + +module.exports = update; diff --git a/devtools/client/debugger/content/reducers/event-listeners.js b/devtools/client/debugger/content/reducers/event-listeners.js new file mode 100644 index 000000000..fdd3da99d --- /dev/null +++ b/devtools/client/debugger/content/reducers/event-listeners.js @@ -0,0 +1,37 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ +"use strict"; + +const constants = require("../constants"); + +const FETCH_EVENT_LISTENERS_DELAY = 200; // ms + +const initialState = { + activeEventNames: [], + listeners: [], + fetchingListeners: false, +}; + +function update(state = initialState, action, emit) { + switch (action.type) { + case constants.UPDATE_EVENT_BREAKPOINTS: + state.activeEventNames = action.eventNames; + 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; + } + + return state; +} + +module.exports = update; diff --git a/devtools/client/debugger/content/reducers/index.js b/devtools/client/debugger/content/reducers/index.js new file mode 100644 index 000000000..27f2059f9 --- /dev/null +++ b/devtools/client/debugger/content/reducers/index.js @@ -0,0 +1,16 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ +"use strict"; + +const eventListeners = require("./event-listeners"); +const sources = require("./sources"); +const breakpoints = require("./breakpoints"); +const asyncRequests = require("./async-requests"); + +module.exports = { + eventListeners, + sources, + breakpoints, + asyncRequests +}; diff --git a/devtools/client/debugger/content/reducers/moz.build b/devtools/client/debugger/content/reducers/moz.build new file mode 100644 index 000000000..0433a099c --- /dev/null +++ b/devtools/client/debugger/content/reducers/moz.build @@ -0,0 +1,12 @@ +# vim: set filetype=python: +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +DevToolsModules( + 'async-requests.js', + 'breakpoints.js', + 'event-listeners.js', + 'index.js', + 'sources.js' +) diff --git a/devtools/client/debugger/content/reducers/sources.js b/devtools/client/debugger/content/reducers/sources.js new file mode 100644 index 000000000..963a52fb5 --- /dev/null +++ b/devtools/client/debugger/content/reducers/sources.js @@ -0,0 +1,128 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ +"use strict"; + +const constants = require("../constants"); +const Immutable = require("devtools/client/shared/vendor/seamless-immutable"); +const { mergeIn, setIn } = require("../utils"); + +const initialState = Immutable({ + sources: {}, + selectedSource: null, + selectedSourceOpts: null, + sourcesText: {} +}); + +function update(state = initialState, action, emitChange) { + switch (action.type) { + case constants.ADD_SOURCE: + emitChange("source", action.source); + return mergeIn(state, ["sources", action.source.actor], action.source); + + case constants.LOAD_SOURCES: + if (action.status === "done") { + const sources = action.value; + if (!sources) { + return state; + } + const sourcesByActor = {}; + sources.forEach(source => { + if (!state.sources[source.actor]) { + emitChange("source", source); + } + sourcesByActor[source.actor] = source; + }); + return mergeIn(state, ["sources"], state.sources.merge(sourcesByActor)); + } + break; + + case constants.SELECT_SOURCE: + emitChange("source-selected", action.source); + return state.merge({ + selectedSource: action.source.actor, + selectedSourceOpts: action.opts + }); + + case constants.LOAD_SOURCE_TEXT: { + const s = _updateText(state, action); + emitChange("source-text-loaded", s.sources[action.source.actor]); + return s; + } + + case constants.BLACKBOX: + if (action.status === "done") { + const s = mergeIn(state, + ["sources", action.source.actor, "isBlackBoxed"], + action.value.isBlackBoxed); + emitChange("blackboxed", s.sources[action.source.actor]); + return s; + } + break; + + case constants.TOGGLE_PRETTY_PRINT: + let s = state; + if (action.status === "error") { + s = mergeIn(state, ["sourcesText", action.source.actor], { + loading: false + }); + + // If it errored, just display the source as it was before, but + // only if there is existing text already. If auto-prettifying + // is on, the original text may still be coming in and we don't + // have it yet. If we try to set empty text we confuse the + // editor because it thinks it's already displaying the source's + // text and won't load the text when it actually comes in. + if (s.sourcesText[action.source.actor].text != null) { + emitChange("prettyprinted", s.sources[action.source.actor]); + } + } + else { + s = _updateText(state, action); + // Don't do this yet, the progress bar is still imperatively shown + // from the source view. We will fix in the next iteration. + // emitChange('source-text-loaded', s.sources[action.source.actor]); + + if (action.status === "done") { + s = mergeIn(s, + ["sources", action.source.actor, "isPrettyPrinted"], + action.value.isPrettyPrinted); + emitChange("prettyprinted", s.sources[action.source.actor]); + } + } + return s; + + case constants.UNLOAD: + // Reset the entire state to just the initial state, a blank state + // if you will. + return initialState; + } + + return state; +} + +function _updateText(state, action) { + const { source } = action; + + if (action.status === "start") { + // Merge this in, don't set it. That way the previous value is + // still stored here, and we can retrieve it if whatever we're + // doing fails. + return mergeIn(state, ["sourcesText", source.actor], { + loading: true + }); + } + else if (action.status === "error") { + return setIn(state, ["sourcesText", source.actor], { + error: action.error + }); + } + else { + return setIn(state, ["sourcesText", source.actor], { + text: action.value.text, + contentType: action.value.contentType + }); + } +} + +module.exports = update; -- cgit v1.2.3