DevTools: extract model from DOMBreakpointsSidebarPane

third_party/WebKit/Source/devtools/front_end/sdk/DOMBreakpointManager.js

Index: third_party/WebKit/Source/devtools/front_end/sdk/DOMBreakpointManager.js
diff --git a/third_party/WebKit/Source/devtools/front_end/sdk/DOMBreakpointManager.js b/third_party/WebKit/Source/devtools/front_end/sdk/DOMBreakpointManager.js
new file mode 100644
index 0000000000000000000000000000000000000000..0b5f3aaaad8e943c5f625222cf4d78bce1d03c66
--- /dev/null
+++ b/third_party/WebKit/Source/devtools/front_end/sdk/DOMBreakpointManager.js
@@ -0,0 +1,285 @@
+// Copyright (c) 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+/**
+ * @constructor
+ * @extends {WebInspector.Object}
+ * @implements {WebInspector.TargetManager.Observer}
+ */
+WebInspector.DOMBreakpointManager = function()
+{
+    /** @type {!Map<!WebInspector.Target, !Protocol.DOMDebuggerAgent>} */
+    this._agents = new Map();
+    this._domBreakpointsSetting = WebInspector.settings.createLocalSetting("domBreakpoints", []);
+    /** @type {!Map<string, !WebInspector.DOMBreakpointManager.Breakpoint>} */
+    this._breakpoints = new Map();
+    WebInspector.targetManager.addModelListener(WebInspector.DOMModel, WebInspector.DOMModel.Events.DocumentUpdated, this._restoreBreakpoints, this);
+    WebInspector.targetManager.addModelListener(WebInspector.DOMModel, WebInspector.DOMModel.Events.NodeRemoved, this._nodeRemoved, this);
+    WebInspector.targetManager.observeTargets(this);
+}
+
+WebInspector.DOMBreakpointManager.Marker = "breakpoint-marker";
+
+WebInspector.DOMBreakpointManager.Events = {
+    BreakpointsChanged: "BreakpointsChanged"
+};
+
+WebInspector.DOMBreakpointManager.prototype = {
+    /**
+     * @override
+     * @param {!WebInspector.Target} target
+     */
+    targetAdded: function(target)
+    {
+        if (target.hasDOMCapability())
+            this._agents.set(target, target.domdebuggerAgent());
+    },
+
+    /**
+     * @override
+     * @param {!WebInspector.Target} target
+     */
+    targetRemoved: function(target)
+    {
+        if (target.hasDOMCapability())
+            this._agents.delete(target);
+    },
+
+    /**
+     * @return {!Array<!WebInspector.DOMBreakpointManager.Breakpoint>}
+     */
+    domBreakpoints: function()
+    {
+        var breakpoints = [];
+        for (var breakpoint of this._breakpoints.values())
+            breakpoints.push(breakpoint);
+        return breakpoints;
+    },
+
+    /**
+     * @param {!WebInspector.DOMNode} node
+     * @param {!DOMDebuggerAgent.DOMBreakpointType} type
+     * @param {boolean} enabled
+     */
+    setBreakpoint: function(node, type, enabled)
+    {
+        this._innerSetBreakpoint(node, type, enabled);
+        this._saveBreakpoints();
+    },
+
+    /**
+     * @param {!WebInspector.DOMNode} node
+     * @param {!DOMDebuggerAgent.DOMBreakpointType} type
+     * @param {boolean} enabled
+     */
+    _innerSetBreakpoint: function(node, type, enabled)
+    {
+        var url = node.ownerDocument.documentURL.removeURLFragment();
+        var breakpoint = new WebInspector.DOMBreakpointManager.Breakpoint(node, type, url, enabled);
+        this._breakpoints.set(this._createBreakpointId(node, type), breakpoint);
+        var agent = this._agents.get(node.target());
+        if (enabled) {
+            agent.setDOMBreakpoint(node.id, type);
+            node.setMarker(WebInspector.DOMBreakpointManager.Marker, true);
+        } else {
+            agent.removeDOMBreakpoint(node.id, type);
+            node.setMarker(WebInspector.DOMBreakpointManager.Marker, this._hasOtherBreakpoints(node, type) ? true : null);
+        }
+    },
+
+    /**
+     * @param {!WebInspector.DOMNode} node
+     * @param {!DOMDebuggerAgent.DOMBreakpointType} type
+     */
+    removeBreakpoint: function(node, type)
+    {
+        this._innerRemoveBreakpoint(node, type);
+        this._saveBreakpoints();
+    },
+
+    /**
+     * @param {!WebInspector.DOMNode} node
+     * @param {!DOMDebuggerAgent.DOMBreakpointType} type
+     */
+    _innerRemoveBreakpoint: function(node, type)
+    {
+        var breakpointId = this._createBreakpointId(node, type);
+        var breakpoint = this._breakpoints.get(breakpointId);
+        if (breakpoint.enabled) {
+            var agent = this._agents.get(node.target());
+            agent.removeDOMBreakpoint(node.id, type);
+            node.setMarker(WebInspector.DOMBreakpointManager.Marker, this._hasOtherBreakpoints(node, type) ? true : null);
+        }
+        this._breakpoints.remove(breakpointId);
+    },
+
+    /**
+     * @param {!WebInspector.DOMNode} node
+     * @param {!DOMDebuggerAgent.DOMBreakpointType} type
+     */
+    toggleBreakpoint: function(node, type)
+    {
+        var nodeBreakpoints = this.nodeBreakpoints(node);
+        if (!nodeBreakpoints.get(type))
+            this.setBreakpoint(node, type, true);
+        else
+            this.removeBreakpoint(node, type);
+    },
+
+    removeAllBreakpoints: function()
+    {
+        for (var breakpoint of this._breakpoints.values())
+            this._innerRemoveBreakpoint(breakpoint.node, breakpoint.type);
+        this._saveBreakpoints();
+    },
+
+    /**
+     * @param {!WebInspector.DOMNode} node
+     * @return {!Map<string, boolean>}
+     */
+    nodeBreakpoints: function(node)
+    {
+        var nodeBreakpoints = new Map();
+        for (var breakpoint of this._breakpoints.values()) {
+            if (breakpoint.node === node && breakpoint.enabled)
+                nodeBreakpoints.set(breakpoint.type, true);
+        }
+        return nodeBreakpoints;
+    },
+
+    /**
+     * @param {!WebInspector.Event} event
+     */
+    _restoreBreakpoints: function(event)
+    {
+        var inspectedRootDocument = /** @type {!WebInspector.DOMDocument} */ (event.data);
+        if (!inspectedRootDocument)
+            return;
+        var domModel = /** @type {!WebInspector.DOMModel} */ (event.target);
+        var pathToBreakpoints = {};
+        this._breakpoints.clear();
+        this.dispatchEventToListeners(WebInspector.DOMBreakpointManager.Events.BreakpointsChanged);
+
+        /**
+         * @param {string} path
+         * @param {?DOMAgent.NodeId} nodeId
+         * @this {WebInspector.DOMBreakpointManager}
+         */
+        function didPushNodeByPathToFrontend(path, nodeId)
+        {
+            var node = nodeId ? domModel.nodeForId(nodeId) : null;
+            if (!node)
+                return;
+
+            for (var breakpoint of pathToBreakpoints[path])
+                this._innerSetBreakpoint(node, breakpoint.type, breakpoint.enabled);
+            this.dispatchEventToListeners(WebInspector.DOMBreakpointManager.Events.BreakpointsChanged);
+        }
+
+        var breakpoints = this._domBreakpointsSetting.get();
+        for (var breakpoint of breakpoints) {
+            if (breakpoint.url !== WebInspector.targetManager.inspectedURL())
+                continue;
+            var path = breakpoint.path;
+            if (!pathToBreakpoints[path]) {
+                pathToBreakpoints[path] = [];
+                domModel.pushNodeByPathToFrontend(path, didPushNodeByPathToFrontend.bind(this, path));
+            }
+            pathToBreakpoints[path].push(breakpoint);
+        }
+    },
+
+    _saveBreakpoints: function()
+    {
+        var breakpoints = [];
+        var storedBreakpoints = this._domBreakpointsSetting.get();
+        for (var breakpoint of storedBreakpoints) {
+            if (breakpoint.url !== WebInspector.targetManager.inspectedURL())
+                breakpoints.push(breakpoint);
+        }
+        for (var breakpoint of this._breakpoints.values()) {
+            breakpoints.push({
+                url: breakpoint.url,
+                path: breakpoint.node.path(),
+                type: breakpoint.type,
+                enabled: breakpoint.enabled
+            });
+        }
+        this._domBreakpointsSetting.set(breakpoints);
+        this.dispatchEventToListeners(WebInspector.DOMBreakpointManager.Events.BreakpointsChanged);
+    },
+
+    /**
+     * @param {!WebInspector.DOMNode} node
+     * @param {!DOMDebuggerAgent.DOMBreakpointType} type
+     * @return {boolean}
+     */
+    _hasOtherBreakpoints: function(node, type)
+    {
+        for (var breakpoint of this._breakpoints.values()) {
+            if (breakpoint.node === node && breakpoint.type !== type && breakpoint.enabled)
+                return true;
+        }
+        return false;
+    },
+
+    /**
+     * @param {!WebInspector.Event} event
+     */
+    _nodeRemoved: function(event)
+    {
+        var node = event.data.node;
+        this._removeBreakpointsForNode(node);
+        var children = node.children();
+        if (!children)
+            return;
+        for (var child of children)
+            this._removeBreakpointsForNode(child);
+    },
+
+    /**
+     * @param {!WebInspector.DOMNode} node
+     */
+    _removeBreakpointsForNode: function(node)
+    {
+        for (var breakpoint of this._breakpoints.values()) {
+            if (breakpoint.node === node)
+                this._innerRemoveBreakpoint(breakpoint.node, breakpoint.type);
+        }
+        this._saveBreakpoints();
+    },
+
+    /**
+     * @param {!WebInspector.DOMNode} node
+     * @param {!DOMDebuggerAgent.DOMBreakpointType} type
+     * @return {string}
+     */
+    _createBreakpointId: function(node, type)
+    {
+        return node.id + ":" + type;
+    },
+
+    __proto__: WebInspector.Object.prototype
+};
+
+/**
+ * @constructor
+ * @param {!WebInspector.DOMNode} node
+ * @param {!DOMDebuggerAgent.DOMBreakpointType} type
+ * @param {string} url
+ * @param {boolean} enabled
+ */
+WebInspector.DOMBreakpointManager.Breakpoint = function(node, type, url, enabled)
+{
+    this.node = node;
+    this.path = node.path();
+    this.type = type;
+    this.url = url;
+    this.enabled = enabled;
+}
+
+/**
+ * @type {!WebInspector.DOMBreakpointManager}
+ */
+WebInspector.domBreakpointManager;