Modified: trunk/Source/WebInspectorUI/.eslintrc (242742 => 242743)
--- trunk/Source/WebInspectorUI/.eslintrc 2019-03-11 21:55:00 UTC (rev 242742)
+++ trunk/Source/WebInspectorUI/.eslintrc 2019-03-11 21:56:32 UTC (rev 242743)
@@ -76,6 +76,7 @@
"InspectorTest": true,
"LinkedList": true,
"ListMultimap": true,
+ "Multimap": true,
"ProtocolTest": true,
"ProtocolTestHarness": true,
"SyncTestSuite": true,
Added: trunk/Source/WebInspectorUI/UserInterface/Base/Multimap.js (0 => 242743)
--- trunk/Source/WebInspectorUI/UserInterface/Base/Multimap.js (rev 0)
+++ trunk/Source/WebInspectorUI/UserInterface/Base/Multimap.js 2019-03-11 21:56:32 UTC (rev 242743)
@@ -0,0 +1,103 @@
+/*
+ * Copyright (C) 2018 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+class Multimap
+{
+ constructor(items = [])
+ {
+ this._map = new Map;
+
+ for (let [key, value] of items)
+ this.add(key, value);
+ }
+
+ // Public
+
+ get(key)
+ {
+ return this._map.get(key);
+ }
+
+ add(key, value)
+ {
+ let valueSet = this._map.get(key);
+ if (!valueSet) {
+ valueSet = new Set;
+ this._map.set(key, valueSet);
+ }
+ valueSet.add(value);
+
+ return this;
+ }
+
+ delete(key, value)
+ {
+ // Allow an entire key to be removed by not passing a value.
+ if (arguments.length === 1)
+ return this._map.delete(key);
+
+ let valueSet = this._map.get(key);
+ if (!valueSet)
+ return false;
+
+ let deleted = valueSet.delete(value);
+
+ if (!valueSet.size)
+ this._map.delete(key);
+
+ return deleted;
+ }
+
+ clear()
+ {
+ this._map.clear();
+ }
+
+ keys()
+ {
+ return this._map.keys();
+ }
+
+ *values()
+ {
+ for (let valueSet of this._map.values()) {
+ for (let value of valueSet)
+ yield value;
+ }
+ }
+
+ *[Symbol.iterator]()
+ {
+ for (let [key, valueSet] of this._map) {
+ for (let value of valueSet)
+ yield [key, value];
+ }
+ }
+
+ toJSON()
+ {
+ return Array.from(this);
+ }
+}
Modified: trunk/Source/WebInspectorUI/UserInterface/Controllers/DOMDebuggerManager.js (242742 => 242743)
--- trunk/Source/WebInspectorUI/UserInterface/Controllers/DOMDebuggerManager.js 2019-03-11 21:55:00 UTC (rev 242742)
+++ trunk/Source/WebInspectorUI/UserInterface/Controllers/DOMDebuggerManager.js 2019-03-11 21:56:32 UTC (rev 242743)
@@ -30,7 +30,7 @@
super();
this._domBreakpointsSetting = new WI.Setting("dom-breakpoints", []);
- this._domBreakpointURLMap = new Map;
+ this._domBreakpointURLMap = new Multimap;
this._domBreakpointFrameIdentifierMap = new Map;
this._eventBreakpointSetting = new WI.Setting("event-breakpoints", []);
@@ -69,10 +69,29 @@
this.addURLBreakpoint(WI.URLBreakpoint.deserialize(serializedInfo));
this._restoringBreakpoints = false;
- this._speculativelyResolveBreakpoints();
+ }
+ }
+ // Target
+
+ initializeTarget(target)
+ {
+ if (target.DOMDebuggerAgent) {
+ if (target === WI.assumingMainTarget() && target.mainResource)
+ this._speculativelyResolveDOMBreakpointsForURL(target.mainResource.url);
+
+ for (let breakpoint of this._eventBreakpoints) {
+ if (!breakpoint.disabled)
+ this._updateEventBreakpoint(breakpoint, target);
+ }
+
+ for (let breakpoint of this._urlBreakpoints) {
+ if (!breakpoint.disabled)
+ this._updateURLBreakpoint(breakpoint, target);
+ }
+
if (!this._allRequestsBreakpoint.disabled)
- this._updateURLBreakpoint(this._allRequestsBreakpoint);
+ this._updateURLBreakpoint(this._allRequestsBreakpoint, target);
}
}
@@ -80,7 +99,7 @@
static supportsEventBreakpoints()
{
- return DOMDebuggerAgent.setEventBreakpoint && DOMDebuggerAgent.removeEventBreakpoint;
+ return InspectorBackend.domains.DOMDebugger.setEventBreakpoint && InspectorBackend.domains.DOMDebugger.removeEventBreakpoint;
}
static supportsURLBreakpoints()
@@ -92,7 +111,7 @@
get supported()
{
- return !!window.DOMDebuggerAgent;
+ return !!InspectorBackend.domains.DOMDebugger;
}
get allRequestsBreakpoint() { return this._allRequestsBreakpoint; }
@@ -154,15 +173,13 @@
return;
}
- let breakpoints = this._domBreakpointURLMap.get(breakpoint.url);
- if (!breakpoints) {
- breakpoints = [breakpoint];
- this._domBreakpointURLMap.set(breakpoint.url, breakpoints);
- } else
- breakpoints.push(breakpoint);
+ this._domBreakpointURLMap.add(breakpoint.url, breakpoint);
- if (breakpoint.domNodeIdentifier)
- this._resolveDOMBreakpoint(breakpoint, breakpoint.domNodeIdentifier);
+ if (!breakpoint.disabled) {
+ let target = WI.assumingMainTarget();
+ if (target && target.DOMDebuggerAgent)
+ this._updateDOMBreakpoint(breakpoint, target);
+ }
this.dispatchEventToListeners(WI.DOMDebuggerManager.Event.DOMBreakpointAdded, {breakpoint});
@@ -188,15 +205,14 @@
this._detachDOMBreakpoint(breakpoint);
- let urlBreakpoints = this._domBreakpointURLMap.get(breakpoint.url);
- urlBreakpoints.remove(breakpoint, true);
+ this._domBreakpointURLMap.delete(breakpoint.url);
- if (!breakpoint.disabled)
- DOMDebuggerAgent.removeDOMBreakpoint(nodeIdentifier, breakpoint.type);
+ if (!breakpoint.disabled) {
+ // We should get the target associated with the nodeIdentifier of this breakpoint.
+ let target = WI.assumingMainTarget();
+ target.DOMDebuggerAgent.removeDOMBreakpoint(nodeIdentifier, breakpoint.type);
+ }
- if (!urlBreakpoints.length)
- this._domBreakpointURLMap.delete(breakpoint.url);
-
this.dispatchEventToListeners(WI.DOMDebuggerManager.Event.DOMBreakpointRemoved, {breakpoint});
breakpoint.domNodeIdentifier = null;
@@ -237,7 +253,13 @@
this.dispatchEventToListeners(WI.DOMDebuggerManager.Event.EventBreakpointAdded, {breakpoint});
- this._resolveEventBreakpoint(breakpoint);
+ if (!breakpoint.disabled) {
+ for (let target of WI.targets) {
+ if (target.DOMDebuggerAgent)
+ this._updateEventBreakpoint(breakpoint, target);
+ }
+ }
+
this._saveEventBreakpoints();
}
@@ -264,19 +286,18 @@
if (breakpoint.disabled)
return;
- function breakpointRemoved(error) {
- if (error)
- console.error(error);
- }
+ for (let target of WI.targets) {
+ if (target.DOMDebuggerAgent) {
+ // Compatibility (iOS 12): DOMDebuggerAgent.removeEventBreakpoint did not exist.
+ if (!WI.DOMDebuggerManager.supportsEventBreakpoints()) {
+ console.assert(breakpoint.type === WI.EventBreakpoint.Type.Listener);
+ target.DOMDebuggerAgent.removeEventListenerBreakpoint(breakpoint.eventName);
+ continue;
+ }
- // Compatibility (iOS 12): DOMDebuggerAgent.removeEventBreakpoint did not exist.
- if (!WI.DOMDebuggerManager.supportsEventBreakpoints()) {
- console.assert(breakpoint.type === WI.EventBreakpoint.Type.Listener);
- DOMDebuggerAgent.removeEventListenerBreakpoint(breakpoint.eventName, breakpointRemoved);
- return;
+ target.DOMDebuggerAgent.removeEventBreakpoint(breakpoint.type, breakpoint.eventName);
+ }
}
-
- DOMDebuggerAgent.removeEventBreakpoint(breakpoint.type, breakpoint.eventName, breakpointRemoved);
}
urlBreakpointForURL(url)
@@ -306,7 +327,13 @@
this.dispatchEventToListeners(WI.DOMDebuggerManager.Event.URLBreakpointAdded, {breakpoint});
- this._resolveURLBreakpoint(breakpoint);
+ if (!breakpoint.disabled) {
+ for (let target of WI.targets) {
+ if (target.DOMDebuggerAgent)
+ this._updateURLBreakpoint(breakpoint, target);
+ }
+ }
+
this._saveURLBreakpoints();
}
@@ -333,17 +360,14 @@
if (breakpoint.disabled)
return;
- // Compatibility (iOS 12.1): DOMDebuggerAgent.removeURLBreakpoint did not exist.
- if (WI.DOMDebuggerManager.supportsURLBreakpoints()) {
- DOMDebuggerAgent.removeURLBreakpoint(breakpoint.url, (error) => {
- if (error)
- console.error(error);
- });
- } else {
- DOMDebuggerAgent.removeXHRBreakpoint(breakpoint.url, (error) => {
- if (error)
- console.error(error);
- });
+ for (let target of WI.targets) {
+ if (target.DOMDebuggerAgent) {
+ // Compatibility (iOS 12.1): DOMDebuggerAgent.removeURLBreakpoint did not exist.
+ if (WI.DOMDebuggerManager.supportsURLBreakpoints())
+ target.DOMDebuggerAgent.removeURLBreakpoint(breakpoint.url);
+ else
+ target.DOMDebuggerAgent.removeXHRBreakpoint(breakpoint.url);
+ }
}
}
@@ -393,32 +417,21 @@
}
}
- _speculativelyResolveBreakpoints()
+ _speculativelyResolveDOMBreakpointsForURL(url)
{
- let mainFrame = WI.networkManager.mainFrame;
- if (!mainFrame)
+ let domBreakpoints = this._domBreakpointURLMap.get(url);
+ if (!domBreakpoints)
return;
- let domBreakpoints = this._domBreakpointURLMap.get(mainFrame.url);
- if (domBreakpoints) {
- for (let breakpoint of domBreakpoints) {
- if (breakpoint.domNodeIdentifier)
- continue;
+ for (let breakpoint of domBreakpoints) {
+ if (breakpoint.domNodeIdentifier)
+ continue;
- WI.domManager.pushNodeByPathToFrontend(breakpoint.path, (nodeIdentifier) => {
- if (!nodeIdentifier)
- return;
-
+ WI.domManager.pushNodeByPathToFrontend(breakpoint.path, (nodeIdentifier) => {
+ if (nodeIdentifier)
this._resolveDOMBreakpoint(breakpoint, nodeIdentifier);
- });
- }
+ });
}
-
- for (let breakpoint of this._eventBreakpoints)
- this._resolveEventBreakpoint(breakpoint);
-
- for (let breakpoint of this._urlBreakpoints)
- this._resolveURLBreakpoint(breakpoint);
}
_resolveDOMBreakpoint(breakpoint, nodeIdentifier)
@@ -443,92 +456,74 @@
breakpoint.domNodeIdentifier = nodeIdentifier;
- this._updateDOMBreakpoint(breakpoint);
+ // We should get the target associated with the nodeIdentifier of this breakpoint.
+ let target = WI.assumingMainTarget();
+ if (target && target.DOMDebuggerAgent)
+ this._updateDOMBreakpoint(breakpoint, target);
}
- _updateDOMBreakpoint(breakpoint)
+ _updateDOMBreakpoint(breakpoint, target)
{
- let nodeIdentifier = breakpoint.domNodeIdentifier;
- if (!nodeIdentifier)
+ console.assert(target.DOMDebuggerAgent);
+
+ if (!breakpoint.domNodeIdentifier)
return;
- function breakpointUpdated(error)
- {
- if (error)
- console.error(error);
- }
-
if (breakpoint.disabled)
- DOMDebuggerAgent.removeDOMBreakpoint(nodeIdentifier, breakpoint.type, breakpointUpdated);
+ target.DOMDebuggerAgent.removeDOMBreakpoint(breakpoint.domNodeIdentifier, breakpoint.type);
else
- DOMDebuggerAgent.setDOMBreakpoint(nodeIdentifier, breakpoint.type, breakpointUpdated);
+ target.DOMDebuggerAgent.setDOMBreakpoint(breakpoint.domNodeIdentifier, breakpoint.type);
}
- _updateEventBreakpoint(breakpoint)
+ _updateEventBreakpoint(breakpoint, target)
{
+ console.assert(target.DOMDebuggerAgent);
+
// Compatibility (iOS 12): DOMDebuggerAgent.removeEventBreakpoint did not exist.
if (!WI.DOMDebuggerManager.supportsEventBreakpoints()) {
console.assert(breakpoint.type === WI.EventBreakpoint.Type.Listener);
if (breakpoint.disabled)
- DOMDebuggerAgent.removeEventListenerBreakpoint(breakpoint.eventName);
+ target.DOMDebuggerAgent.removeEventListenerBreakpoint(breakpoint.eventName);
else
- DOMDebuggerAgent.setEventListenerBreakpoint(breakpoint.eventName);
+ target.DOMDebuggerAgent.setEventListenerBreakpoint(breakpoint.eventName);
return;
}
if (breakpoint.disabled)
- DOMDebuggerAgent.removeEventBreakpoint(breakpoint.type, breakpoint.eventName);
+ target.DOMDebuggerAgent.removeEventBreakpoint(breakpoint.type, breakpoint.eventName);
else
- DOMDebuggerAgent.setEventBreakpoint(breakpoint.type, breakpoint.eventName);
+ target.DOMDebuggerAgent.setEventBreakpoint(breakpoint.type, breakpoint.eventName);
}
- _updateURLBreakpoint(breakpoint)
+ _updateURLBreakpoint(breakpoint, target)
{
+ console.assert(target.DOMDebuggerAgent);
+
// Compatibility (iOS 12.1): DOMDebuggerAgent.removeURLBreakpoint did not exist.
if (!WI.DOMDebuggerManager.supportsURLBreakpoints()) {
if (breakpoint.disabled)
- DOMDebuggerAgent.removeXHRBreakpoint(breakpoint.url);
+ target.DOMDebuggerAgent.removeXHRBreakpoint(breakpoint.url);
else {
let isRegex = breakpoint.type === WI.URLBreakpoint.Type.RegularExpression;
- DebuggerAgent.setXHRBreakpoint(breakpoint.url, isRegex);
+ target.DOMDebuggerAgent.setXHRBreakpoint(breakpoint.url, isRegex);
}
return;
}
if (breakpoint.disabled)
- DOMDebuggerAgent.removeURLBreakpoint(breakpoint.url);
+ target.DOMDebuggerAgent.removeURLBreakpoint(breakpoint.url);
else {
let isRegex = breakpoint.type === WI.URLBreakpoint.Type.RegularExpression;
- DOMDebuggerAgent.setURLBreakpoint(breakpoint.url, isRegex);
+ target.DOMDebuggerAgent.setURLBreakpoint(breakpoint.url, isRegex);
}
}
- _resolveEventBreakpoint(breakpoint)
- {
- if (breakpoint.disabled)
- return;
-
- this._updateEventBreakpoint(breakpoint);
- }
-
- _resolveURLBreakpoint(breakpoint)
- {
- if (breakpoint.disabled)
- return;
-
- this._updateURLBreakpoint(breakpoint);
- }
-
_saveDOMBreakpoints()
{
if (this._restoringBreakpoints)
return;
- let breakpointsToSave = [];
- for (let breakpoints of this._domBreakpointURLMap.values())
- breakpointsToSave = breakpointsToSave.concat(breakpoints);
-
- this._domBreakpointsSetting.value = breakpointsToSave.map((breakpoint) => breakpoint.serializableInfo);
+ this._domBreakpointsSetting.value = Array.from(this._domBreakpointURLMap.values()).map((breakpoint) => breakpoint.serializableInfo);
}
_saveEventBreakpoints()
@@ -550,7 +545,10 @@
_handleDOMBreakpointDisabledStateChanged(event)
{
let breakpoint = event.target;
- this._updateDOMBreakpoint(breakpoint);
+ let target = WI.assumingMainTarget();
+ if (target && target.DOMDebuggerAgent)
+ this._updateDOMBreakpoint(breakpoint, target);
+
this._saveDOMBreakpoints();
}
@@ -557,7 +555,10 @@
_handleEventBreakpointDisabledStateChanged(event)
{
let breakpoint = event.target;
- this._updateEventBreakpoint(breakpoint);
+ for (let target of WI.targets) {
+ if (target.DOMDebuggerAgent)
+ this._updateEventBreakpoint(breakpoint, target);
+ }
this._saveEventBreakpoints();
}
@@ -568,7 +569,10 @@
if (breakpoint === this._allRequestsBreakpoint)
this._allRequestsBreakpointEnabledSetting.value = !breakpoint.disabled;
- this._updateURLBreakpoint(breakpoint);
+ for (let target of WI.targets) {
+ if (target.DOMDebuggerAgent)
+ this._updateURLBreakpoint(breakpoint, target);
+ }
this._saveURLBreakpoints();
}
@@ -578,9 +582,9 @@
this._detachBreakpointsForFrame(frame);
}
- _mainFrameDidChange()
+ _mainFrameDidChange(event)
{
- this._speculativelyResolveBreakpoints();
+ this._speculativelyResolveDOMBreakpointsForURL(WI.networkManager.mainFrame.url);
}
_mainResourceDidChange(event)
@@ -587,14 +591,14 @@
{
let frame = event.target;
if (frame.isMainFrame()) {
- for (let breakpoints of this._domBreakpointURLMap.values())
- breakpoints.forEach((breakpoint) => { breakpoint.domNodeIdentifier = null; });
+ for (let breakpoint of this._domBreakpointURLMap.values())
+ breakpoint.domNodeIdentifier = null;
this._domBreakpointFrameIdentifierMap.clear();
} else
this._detachBreakpointsForFrame(frame);
- this._speculativelyResolveBreakpoints();
+ this._speculativelyResolveDOMBreakpointsForURL(frame.url);
}
_nodeInserted(event)
