Attachment 364288 Details for Bug 195248 – Patch

[patch] Patch

bug-195248-20190311142946.patch (text/plain), 24.34 KB, created by Devin Rousso on 2019-03-11 14:29:48 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Devin Rousso

Created: 2019-03-11 14:29:48 PDT

Size: 24.34 KB

patch

obsolete

>diff --git a/Source/WebInspectorUI/ChangeLog b/Source/WebInspectorUI/ChangeLog
>index c38214b960c528ce4cbd2c70ab4158f66ce90b72..3e90baac7843f78a11817854f15789baa94d672e 100644
>--- a/Source/WebInspectorUI/ChangeLog
>+++ b/Source/WebInspectorUI/ChangeLog
>@@ -1,3 +1,57 @@
>+2019-03-11  Devin Rousso  <drousso@apple.com>
>+
>+        Web Inspector: DOMDebugger: protocol error on first open
>+        https://bugs.webkit.org/show_bug.cgi?id=195248
>+        <rdar://problem/48538465>
>+
>+        Reviewed by Joseph Pecoraro.
>+
>+        Don't try to call `DOMDebugger` commands until a target has been initialized.
>+        Still attempt to resolve DOM breakpoints whenever the main resource/frame changes.
>+
>+        * UserInterface/Controllers/DOMDebuggerManager.js:
>+        (WI.DOMDebuggerManager):
>+        (WI.DOMDebuggerManager.prototype.initializeTarget): Added.
>+        (WI.DOMDebuggerManager.supportsEventBreakpoints):
>+        (WI.DOMDebuggerManager.prototype.get supported):
>+        (WI.DOMDebuggerManager.prototype.addDOMBreakpoint):
>+        (WI.DOMDebuggerManager.prototype.removeDOMBreakpoint):
>+        (WI.DOMDebuggerManager.prototype.addEventBreakpoint):
>+        (WI.DOMDebuggerManager.prototype.removeEventBreakpoint):
>+        (WI.DOMDebuggerManager.prototype.addURLBreakpoint):
>+        (WI.DOMDebuggerManager.prototype.removeURLBreakpoint):
>+        (WI.DOMDebuggerManager.prototype._speculativelyResolveDOMBreakpointsForURL): Added.
>+        (WI.DOMDebuggerManager.prototype._resolveDOMBreakpoint):
>+        (WI.DOMDebuggerManager.prototype._updateDOMBreakpoint):
>+        (WI.DOMDebuggerManager.prototype._updateEventBreakpoint):
>+        (WI.DOMDebuggerManager.prototype._updateURLBreakpoint):
>+        (WI.DOMDebuggerManager.prototype._saveDOMBreakpoints):
>+        (WI.DOMDebuggerManager.prototype._handleDOMBreakpointDisabledStateChanged):
>+        (WI.DOMDebuggerManager.prototype._handleEventBreakpointDisabledStateChanged):
>+        (WI.DOMDebuggerManager.prototype._handleURLBreakpointDisabledStateChanged):
>+        (WI.DOMDebuggerManager.prototype._mainFrameDidChange):
>+        (WI.DOMDebuggerManager.prototype._mainResourceDidChange):
>+        (WI.DOMDebuggerManager.prototype.removeEventBreakpoint.breakpointRemoved): Deleted.
>+        (WI.DOMDebuggerManager.prototype._speculativelyResolveBreakpoints): Deleted.
>+        (WI.DOMDebuggerManager.prototype._updateDOMBreakpoint.breakpointUpdated): Deleted.
>+        (WI.DOMDebuggerManager.prototype._resolveEventBreakpoint): Deleted.
>+        (WI.DOMDebuggerManager.prototype._resolveURLBreakpoint): Deleted.
>+
>+        * UserInterface/Base/Multimap.js: Added.
>+        (Multimap):
>+        (Multimap.prototype.get):
>+        (Multimap.prototype.add):
>+        (Multimap.prototype.delete):
>+        (Multimap.prototype.clear):
>+        (Multimap.prototype.keys):
>+        (Multimap.prototype.*values):
>+        (Multimap.prototype.*[Symbol.iterator]):
>+        (Multimap.prototype.toJSON):
>+        * .eslintrc:
>+        * UserInterface/Main.html:
>+        * UserInterface/Test.html:
>+        Helper data structure for managing Maps of Sets (e.g. all DOM breakpoints for a URL).
>+
> 2019-03-11  Devin Rousso  <drousso@apple.com>
> 
>         Web Inspector: eliminate manual syncing of numeric constants used by JavaScript and CSS
>diff --git a/Source/WebInspectorUI/.eslintrc b/Source/WebInspectorUI/.eslintrc
>index d20104356d8d3a131618794f34e436ccac16934e..e503f7c75d968a74b7542550895aadff62552669 100644
>--- a/Source/WebInspectorUI/.eslintrc
>+++ b/Source/WebInspectorUI/.eslintrc
>@@ -76,6 +76,7 @@
>         "InspectorTest": true,
>         "LinkedList": true,
>         "ListMultimap": true,
>+        "Multimap": true,
>         "ProtocolTest": true,
>         "ProtocolTestHarness": true,
>         "SyncTestSuite": true,
>diff --git a/Source/WebInspectorUI/UserInterface/Base/Multimap.js b/Source/WebInspectorUI/UserInterface/Base/Multimap.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..f03aeadfd35a87f4f08e987d9aee03c6612b4d34
>--- /dev/null
>+++ b/Source/WebInspectorUI/UserInterface/Base/Multimap.js
>@@ -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);
>+    }
>+}
>diff --git a/Source/WebInspectorUI/UserInterface/Controllers/DOMDebuggerManager.js b/Source/WebInspectorUI/UserInterface/Controllers/DOMDebuggerManager.js
>index 9840569955a1ee85cf2544b9cae6cc81899fb11d..40c054d6d0382f36df7e721210eb5311cd2c4fc8 100644
>--- a/Source/WebInspectorUI/UserInterface/Controllers/DOMDebuggerManager.js
>+++ b/Source/WebInspectorUI/UserInterface/Controllers/DOMDebuggerManager.js
>@@ -30,7 +30,7 @@ WI.DOMDebuggerManager = class DOMDebuggerManager extends WI.Object
>         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 @@ WI.DOMDebuggerManager = class DOMDebuggerManager extends WI.Object
>                 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 @@ WI.DOMDebuggerManager = class DOMDebuggerManager extends WI.Object
> 
>     static supportsEventBreakpoints()
>     {
>-        return DOMDebuggerAgent.setEventBreakpoint && DOMDebuggerAgent.removeEventBreakpoint;
>+        return InspectorBackend.domains.DOMDebugger.setEventBreakpoint && InspectorBackend.domains.DOMDebugger.removeEventBreakpoint;
>     }
> 
>     static supportsURLBreakpoints()
>@@ -92,7 +111,7 @@ WI.DOMDebuggerManager = class DOMDebuggerManager extends WI.Object
> 
>     get supported()
>     {
>-        return !!window.DOMDebuggerAgent;
>+        return !!InspectorBackend.domains.DOMDebugger;
>     }
> 
>     get allRequestsBreakpoint() { return this._allRequestsBreakpoint; }
>@@ -154,15 +173,13 @@ WI.DOMDebuggerManager = class DOMDebuggerManager extends WI.Object
>             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,14 +205,13 @@ WI.DOMDebuggerManager = class DOMDebuggerManager extends WI.Object
> 
>         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 (!urlBreakpoints.length)
>-            this._domBreakpointURLMap.delete(breakpoint.url);
>+        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);
>+        }
> 
>         this.dispatchEventToListeners(WI.DOMDebuggerManager.Event.DOMBreakpointRemoved, {breakpoint});
> 
>@@ -237,7 +253,13 @@ WI.DOMDebuggerManager = class DOMDebuggerManager extends WI.Object
> 
>         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 @@ WI.DOMDebuggerManager = class DOMDebuggerManager extends WI.Object
>         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 @@ WI.DOMDebuggerManager = class DOMDebuggerManager extends WI.Object
> 
>         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 @@ WI.DOMDebuggerManager = class DOMDebuggerManager extends WI.Object
>         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 @@ WI.DOMDebuggerManager = class DOMDebuggerManager extends WI.Object
>         }
>     }
> 
>-    _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;
>-
>-                WI.domManager.pushNodeByPathToFrontend(breakpoint.path, (nodeIdentifier) => {
>-                    if (!nodeIdentifier)
>-                        return;
>+        for (let breakpoint of domBreakpoints) {
>+            if (breakpoint.domNodeIdentifier)
>+                continue;
> 
>+            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 @@ WI.DOMDebuggerManager = class DOMDebuggerManager extends WI.Object
> 
>         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,14 +545,20 @@ WI.DOMDebuggerManager = class DOMDebuggerManager extends WI.Object
>     _handleDOMBreakpointDisabledStateChanged(event)
>     {
>         let breakpoint = event.target;
>-        this._updateDOMBreakpoint(breakpoint);
>+        let target = WI.assumingMainTarget();
>+        if (target && target.DOMDebuggerAgent)
>+            this._updateDOMBreakpoint(breakpoint, target);
>+
>         this._saveDOMBreakpoints();
>     }
> 
>     _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 @@ WI.DOMDebuggerManager = class DOMDebuggerManager extends WI.Object
>         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,23 +582,23 @@ WI.DOMDebuggerManager = class DOMDebuggerManager extends WI.Object
>         this._detachBreakpointsForFrame(frame);
>     }
> 
>-    _mainFrameDidChange()
>+    _mainFrameDidChange(event)
>     {
>-        this._speculativelyResolveBreakpoints();
>+        this._speculativelyResolveDOMBreakpointsForURL(WI.networkManager.mainFrame.url);
>     }
> 
>     _mainResourceDidChange(event)
>     {
>         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)
>diff --git a/Source/WebInspectorUI/UserInterface/Main.html b/Source/WebInspectorUI/UserInterface/Main.html
>index b7ab243876a1833d0eb67a3b3c101e1cac89a110..3638a9406d00d21d0b8d9f7d09359290fd8caa21 100644
>--- a/Source/WebInspectorUI/UserInterface/Main.html
>+++ b/Source/WebInspectorUI/UserInterface/Main.html
>@@ -283,6 +283,7 @@
>     <script src="Base/DebuggableType.js"></script>
>     <script src="Base/LinkedList.js"></script>
>     <script src="Base/ListMultimap.js"></script>
>+    <script src="Base/Multimap.js"></script>
>     <script src="Base/Object.js"></script>
>     <script src="Base/Throttler.js"></script>
> 
>diff --git a/Source/WebInspectorUI/UserInterface/Test.html b/Source/WebInspectorUI/UserInterface/Test.html
>index 1b4d6dece552822d9fd97b31aa02409ef1d2faa5..2afdf8afa2c576d9c64ab077f6781ef4f24c7995 100644
>--- a/Source/WebInspectorUI/UserInterface/Test.html
>+++ b/Source/WebInspectorUI/UserInterface/Test.html
>@@ -41,6 +41,7 @@
>     <script src="Base/DebuggableType.js"></script>
>     <script src="Base/LinkedList.js"></script>
>     <script src="Base/ListMultimap.js"></script>
>+    <script src="Base/Multimap.js"></script>
>     <script src="Base/Object.js"></script>
>     <script src="Base/Throttler.js"></script>
>

Actions: View | Formatted Diff | Diff

Attachments on bug 195248: 363433 | 363858 | 363859 | 364288