DevTools: introduce TargetBreakpoints as a presentation of breakpoint and its state within target

Source/devtools/front_end/sdk/BreakpointManager.js

 /*
  * Copyright (C) 2011 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 13 matching lines @@
  * 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.
  */
 
 /**
  * @constructor
  * @extends {WebInspector.Object}
- * @implements {WebInspector.TargetManager.Observer}
  * @param {!WebInspector.Setting} breakpointStorage
  * @param {!WebInspector.Workspace} workspace
  * @param {!WebInspector.TargetManager} targetManager
  */
 WebInspector.BreakpointManager = function(breakpointStorage, workspace, targetManager)
 {
     this._storage = new WebInspector.BreakpointManager.Storage(this, breakpointStorage);
     this._workspace = workspace;
     this._targetManager = targetManager;
 
-    this._breakpointForDebuggerId = {};
     this._breakpointsForUISourceCode = new Map();
     this._breakpointsForPrimaryUISourceCode = new Map();
     /** @type {!StringMultimap.<!WebInspector.BreakpointManager.Breakpoint>} */
     this._provisionalBreakpoints = new StringMultimap();
 
+    /** @type {!Array.<!WebInspector.BreakpointManager.Breakpoint>}*/
+    this._breakpoints = [];
+
     this._workspace.addEventListener(WebInspector.Workspace.Events.ProjectWillReset, this._projectWillReset, this);
     this._workspace.addEventListener(WebInspector.Workspace.Events.UISourceCodeAdded, this._uiSourceCodeAdded, this);
     this._workspace.addEventListener(WebInspector.Workspace.Events.UISourceCodeRemoved, this._uiSourceCodeRemoved, this);
-    this._targetManager.observeTargets(this);
 }
 
 WebInspector.BreakpointManager.Events = {
     BreakpointAdded: "breakpoint-added",
     BreakpointRemoved: "breakpoint-removed"
 }
 
 WebInspector.BreakpointManager._sourceFileId = function(uiSourceCode)
 {
     if (!uiSourceCode.url)
         return "";
     return uiSourceCode.uri();
 }
 
 /**
  * @param {string} sourceFileId
  * @param {number} lineNumber
  * @param {number} columnNumber
  * @return {string}
  */
 WebInspector.BreakpointManager._breakpointStorageId = function(sourceFileId, lineNumber, columnNumber)
 {
     if (!sourceFileId)
         return "";
     return sourceFileId + ":" + lineNumber + ":" + columnNumber;
 }
 
 WebInspector.BreakpointManager.prototype = {
-    /**
-     * @param {!WebInspector.Target} target
-     */
-    targetAdded: function(target)
-    {
-        target.debuggerModel.addEventListener(WebInspector.DebuggerModel.Events.BreakpointResolved, this._breakpointResolved, this);
-    },
-
-    /**
-     * @param {!WebInspector.Target} target
-     */
-    targetRemoved: function(target)
-    {
-        target.debuggerModel.removeEventListener(WebInspector.DebuggerModel.Events.BreakpointResolved, this._breakpointResolved, this);
-    },
 
     /**
      * @param {string} sourceFileId
      * @return {!StringMap.<!WebInspector.BreakpointManager.Breakpoint>}
      */
     _provisionalBreakpointsForSourceFileId: function(sourceFileId)
     {
         var result = new StringMap();
         var breakpoints = this._provisionalBreakpoints.get(sourceFileId).values();
         for (var i = 0; i < breakpoints.length; ++i)
             result.put(breakpoints[i]._breakpointStorageId(), breakpoints[i]);
         return result;
     },
 
     /**
      * @param {!WebInspector.Target} target
      */
     removeProvisionalBreakpointsForTest: function(target)
     {
         var breakpoints = this._provisionalBreakpoints.values();
-        for (var i = 0; i < breakpoints.length; ++i) {
-            var debuggerId = breakpoints[i]._debuggerId;
-            if (debuggerId)
-                target.debuggerModel.removeBreakpoint(debuggerId);
-        }
+        for (var i = 0; i < breakpoints.length; ++i)
+            breakpoints[i].removeProvisionalBreakpointsForTest(target);
         this._provisionalBreakpoints.clear();
     },
 
     /**
      * @param {!WebInspector.UISourceCode} uiSourceCode
      */
     _restoreBreakpoints: function(uiSourceCode)
     {
         var sourceFileId = WebInspector.BreakpointManager._sourceFileId(uiSourceCode);
         if (!sourceFileId)
             return;
 
         this._storage.mute();
         var breakpointItems = this._storage.breakpointItems(uiSourceCode);
         var provisionalBreakpoints = this._provisionalBreakpointsForSourceFileId(sourceFileId);
         for (var i = 0; i < breakpointItems.length; ++i) {
             var breakpointItem = breakpointItems[i];
             var itemStorageId = WebInspector.BreakpointManager._breakpointStorageId(breakpointItem.sourceFileId, breakpointItem.lineNumber, breakpointItem.columnNumber);
             var provisionalBreakpoint = provisionalBreakpoints.get(itemStorageId);
             if (provisionalBreakpoint) {
                 if (!this._breakpointsForPrimaryUISourceCode.get(uiSourceCode))
                     this._breakpointsForPrimaryUISourceCode.put(uiSourceCode, []);
                 this._breakpointsForPrimaryUISourceCode.get(uiSourceCode).push(provisionalBreakpoint);
-                provisionalBreakpoint._updateInDebugger();
+                delete provisionalBreakpoint._provisioned;
+                provisionalBreakpoint._updateBreakpoint();
             } else {
                 this._innerSetBreakpoint(uiSourceCode, breakpointItem.lineNumber, breakpointItem.columnNumber, breakpointItem.condition, breakpointItem.enabled);
             }
         }
         this._provisionalBreakpoints.removeAll(sourceFileId);
         this._storage.unmute();
     },
 
     /**
      * @param {!WebInspector.Event} event
@@ skipping 30 matching lines @@
     },
 
     /**
      * @param {!WebInspector.UISourceCode} uiSourceCode
      */
     _removeUISourceCode: function(uiSourceCode)
     {
         var breakpoints = this._breakpointsForPrimaryUISourceCode.get(uiSourceCode) || [];
         var sourceFileId = WebInspector.BreakpointManager._sourceFileId(uiSourceCode);
         for (var i = 0; i < breakpoints.length; ++i) {
+            if (breakpoints[i].enabled()) {
+                this._provisionalBreakpoints.put(sourceFileId, breakpoints[i]);
+                breakpoints[i]._provisioned = true;
+            }
             breakpoints[i]._resetLocations();
-            if (breakpoints[i].enabled())
-                this._provisionalBreakpoints.put(sourceFileId, breakpoints[i]);
         }
         uiSourceCode.removeEventListener(WebInspector.UISourceCode.Events.SourceMappingChanged, this._uiSourceCodeMappingChanged, this);
         this._breakpointsForPrimaryUISourceCode.remove(uiSourceCode);
     },
 
     /**
      * @param {!WebInspector.UISourceCode} uiSourceCode
      * @param {number} lineNumber
      * @param {number} columnNumber
      * @param {string} condition
@@ skipping 13 matching lines @@
      * @param {number} lineNumber
      * @param {number} columnNumber
      * @param {string} condition
      * @param {boolean} enabled
      * @return {!WebInspector.BreakpointManager.Breakpoint}
      */
     _innerSetBreakpoint: function(uiSourceCode, lineNumber, columnNumber, condition, enabled)
     {
         var breakpoint = this.findBreakpoint(uiSourceCode, lineNumber, columnNumber);
         if (breakpoint) {
-            breakpoint._updateBreakpoint(condition, enabled);
+            breakpoint._setNewState(condition, enabled);
             return breakpoint;
         }
         var projectId = uiSourceCode.project().id();
         var path = uiSourceCode.path();
         var sourceFileId = WebInspector.BreakpointManager._sourceFileId(uiSourceCode);
         breakpoint = new WebInspector.BreakpointManager.Breakpoint(this, projectId, path, sourceFileId, lineNumber, columnNumber, condition, enabled);
+        this._breakpoints.push(breakpoint);
         if (!this._breakpointsForPrimaryUISourceCode.get(uiSourceCode))
             this._breakpointsForPrimaryUISourceCode.put(uiSourceCode, []);
         this._breakpointsForPrimaryUISourceCode.get(uiSourceCode).push(breakpoint);
         return breakpoint;
     },
 
     /**
      * @param {!WebInspector.UISourceCode} uiSourceCode
      * @param {number} lineNumber
      * @param {number} columnNumber
@@ skipping 104 matching lines @@
     },
 
     _projectWillReset: function(event)
     {
         var project = /** @type {!WebInspector.Project} */ (event.data);
         var uiSourceCodes = project.uiSourceCodes();
         for (var i = 0; i < uiSourceCodes.length; ++i)
             this._removeUISourceCode(uiSourceCodes[i]);
     },
 
-    _breakpointResolved: function(event)
-    {
-        var breakpointId = /** @type {!DebuggerAgent.BreakpointId} */ (event.data.breakpointId);
-        var location = /** @type {!WebInspector.DebuggerModel.Location} */ (event.data.location);
-        var breakpoint = this._breakpointForDebuggerId[breakpointId];
-        if (!breakpoint)
-            return;
-        breakpoint._addResolvedLocation(location);
-    },
-
     /**
      * @param {!WebInspector.BreakpointManager.Breakpoint} breakpoint
      * @param {boolean} removeFromStorage
      */
     _removeBreakpoint: function(breakpoint, removeFromStorage)
     {
         var uiSourceCode = breakpoint.uiSourceCode();
         var breakpoints = uiSourceCode ? this._breakpointsForPrimaryUISourceCode.get(uiSourceCode) || [] : [];
-        var index = breakpoints.indexOf(breakpoint);
-        if (index > -1)
-            breakpoints.splice(index, 1);
+        breakpoints.remove(breakpoint);
+        this._breakpoints.remove(breakpoint);
         if (removeFromStorage)
             this._storage._removeBreakpoint(breakpoint);
         this._provisionalBreakpoints.remove(breakpoint._sourceFileId, breakpoint);
     },
 
     /**
      * @param {!WebInspector.BreakpointManager.Breakpoint} breakpoint
      * @param {!WebInspector.UILocation} uiLocation
      */
     _uiLocationAdded: function(breakpoint, uiLocation)
@@ skipping 41 matching lines @@
         if (!breakpoints.size())
             this._breakpointsForUISourceCode.remove(uiLocation.uiSourceCode);
         this.dispatchEventToListeners(WebInspector.BreakpointManager.Events.BreakpointRemoved, {breakpoint: breakpoint, uiLocation: uiLocation});
     },
 
     __proto__: WebInspector.Object.prototype
 }
 
 /**
  * @constructor
+ * @implements {WebInspector.TargetManager.Observer}
  * @param {!WebInspector.BreakpointManager} breakpointManager
  * @param {string} projectId
  * @param {string} path
  * @param {string} sourceFileId
  * @param {number} lineNumber
  * @param {number} columnNumber
  * @param {string} condition
  * @param {boolean} enabled
  */
 WebInspector.BreakpointManager.Breakpoint = function(breakpointManager, projectId, path, sourceFileId, lineNumber, columnNumber, condition, enabled)
 {
     this._breakpointManager = breakpointManager;
     this._projectId = projectId;
     this._path = path;
     this._lineNumber = lineNumber;
     this._columnNumber = columnNumber;
     this._sourceFileId = sourceFileId;
-    /** @type {!Array.<!WebInspector.Script.Location>} */
-    this._liveLocations = [];
-    /** @type {!Object.<string, !WebInspector.UILocation>} */
-    this._uiLocations = {};
 
     /** @type {!Object.<string, number>} */
-    this._numberOfDebuggerLocationForUILocation = new Map();
+    this._numberOfDebuggerLocationForUILocation = {};
 
     // Force breakpoint update.
     /** @type {string} */ this._condition;
     /** @type {boolean} */ this._enabled;
-    this._updateBreakpoint(condition, enabled);
+    /** @type {boolean} */ this._isRemoved;
+    /** @type {!WebInspector.UILocation|undefined} */ this._fakeBreakpointPrimaryLocation;
+
+    /** @type {!Map.<!WebInspector.Target, !WebInspector.BreakpointManager.TargetBreakpoint>}*/
+    this._targetBreakpoints = new Map();
+    this._breakpointManager._targetManager.observeTargets(this);
+    this._setNewState(condition, enabled);
 }
 
 WebInspector.BreakpointManager.Breakpoint.prototype = {
     /**
+     * @param {!WebInspector.Target} target
+     */
+    targetAdded: function(target)
+    {
+        target.debuggerModel.addEventListener(WebInspector.DebuggerModel.Events.BreakpointResolved, this._breakpointResolved, this);
+        this._targetBreakpoints.put(target, new WebInspector.BreakpointManager.TargetBreakpoint(target, this));
+    },
+
+    /**
+     * @param {!WebInspector.Target} target
+     */
+    targetRemoved: function(target)
+    {
+        target.debuggerModel.removeEventListener(WebInspector.DebuggerModel.Events.BreakpointResolved, this._breakpointResolved, this);
+        var targetBreakpoint = this._targetBreakpoints.remove(target);
+        targetBreakpoint._resetLocations();
+    },
+
+    /**
+     * @param {!WebInspector.Target} target
+     */
+    removeProvisionalBreakpointsForTest: function(target)
+    {
+        var debuggerId = this._targetBreakpoints.get(target)._debuggerId;
+        if (debuggerId)
+            target.debuggerModel.removeBreakpoint(debuggerId);
+    },
+
+    /**
      * @return {string}
      */
     projectId: function()
     {
         return this._projectId;
     },
 
     /**
      * @return {string}
      */
@@ skipping 20 matching lines @@
 
     /**
      * @return {?WebInspector.UISourceCode}
      */
     uiSourceCode: function()
     {
         return this._breakpointManager._workspace.uiSourceCode(this._projectId, this._path);
     },
 
     /**
-     * @param {!WebInspector.DebuggerModel.Location} location
-     * @return {boolean}
+     * @param {?WebInspector.UILocation} oldUILocation
+     * @param {!WebInspector.UILocation} newUILocation
      */
-    _addResolvedLocation: function(location)
+    _replaceUILocation: function(oldUILocation, newUILocation)
     {
-        var script = location.script();
-        var uiLocation = script.rawLocationToUILocation(location.lineNumber, location.columnNumber);
-        var breakpoint = this._breakpointManager.findBreakpoint(uiLocation.uiSourceCode, uiLocation.lineNumber, uiLocation.columnNumber);
-        if (breakpoint && breakpoint != this) {
-            // location clash
-            this.remove();
-            return false;
-        }
-        this._liveLocations.push(location.createLiveLocation(this._locationUpdated.bind(this, location)));
-        return true;
+        if (this._isRemoved)
+            return;
+
+        this._removeUILocation(oldUILocation, true);
+        this._removeFakeBreakpointAtPrimaryLocation();
+
+        if (!this._numberOfDebuggerLocationForUILocation[newUILocation.id()])
+            this._numberOfDebuggerLocationForUILocation[newUILocation.id()] = 0;
+
+        if (++this._numberOfDebuggerLocationForUILocation[newUILocation.id()] === 1)
+            this._breakpointManager._uiLocationAdded(this, newUILocation);
     },
 
     /**
-     * @param {!WebInspector.DebuggerModel.Location} location
-     * @param {!WebInspector.UILocation} uiLocation
+     * @param {?WebInspector.UILocation} uiLocation
+     * @param {boolean=} muteCreationFakeBreakpoint
      */
-    _locationUpdated: function(location, uiLocation)
+    _removeUILocation: function(uiLocation, muteCreationFakeBreakpoint)
     {
-        var oldUILocation = /** @type {!WebInspector.UILocation} */ (this._uiLocations[location.id()]);
-        if (oldUILocation && --this._numberOfDebuggerLocationForUILocation[oldUILocation.id()] === 0) {
-            delete this._numberOfDebuggerLocationForUILocation[oldUILocation.id()];
-            this._breakpointManager._uiLocationRemoved(this, oldUILocation);
-        }
-        if (this._uiLocations[""]) {
-            var defaultLocation = this._uiLocations[""];
-            delete this._uiLocations[""];
-            this._breakpointManager._uiLocationRemoved(this, defaultLocation);
-        }
-        this._uiLocations[location.id()] = uiLocation;
+        if (!uiLocation || --this._numberOfDebuggerLocationForUILocation[uiLocation.id()] !== 0)
+            return;
 
-        if (!this._numberOfDebuggerLocationForUILocation[uiLocation.id()])
-            this._numberOfDebuggerLocationForUILocation[uiLocation.id()] = 0;
-
-        if (++this._numberOfDebuggerLocationForUILocation[uiLocation.id()] === 1)
-            this._breakpointManager._uiLocationAdded(this, uiLocation);
+        delete this._numberOfDebuggerLocationForUILocation[uiLocation.id()];
+        this._breakpointManager._uiLocationRemoved(this, uiLocation);
+        if (!muteCreationFakeBreakpoint)
+            this._fakeBreakpointAtPrimaryLocation();
     },
 
     /**
      * @return {boolean}
      */
     enabled: function()
     {
         return this._enabled;
     },
 
     /**
      * @param {boolean} enabled
      */
     setEnabled: function(enabled)
     {
-        this._updateBreakpoint(this._condition, enabled);
+        this._setNewState(this._condition, enabled);
     },
 
     /**
      * @return {string}
      */
     condition: function()
     {
         return this._condition;
     },
 
     /**
      * @param {string} condition
      */
     setCondition: function(condition)
     {
-        this._updateBreakpoint(condition, this._enabled);
+        this._setNewState(condition, this._enabled);
     },
 
     /**
      * @param {string} condition
      * @param {boolean} enabled
      */
-    _updateBreakpoint: function(condition, enabled)
+    _setNewState: function(condition, enabled)
     {
         if (this._enabled === enabled && this._condition === condition)
             return;
         this._enabled = enabled;
         this._condition = condition;
         this._breakpointManager._storage._updateBreakpoint(this);
+        this._updateBreakpoint();
+    },
+
+    _updateBreakpoint: function()
+    {
+        this._removeFakeBreakpointAtPrimaryLocation();
+        this._fakeBreakpointAtPrimaryLocation();
         this._updateInDebugger();
     },
 
     /**
      * @param {boolean=} keepInStorage
      */
     remove: function(keepInStorage)
     {
+        this._isRemoved = true;
         var removeFromStorage = !keepInStorage;
+        this._removeFakeBreakpointAtPrimaryLocation();
+        var targets = this._targetBreakpoints.keys();
+        for (var i = 0; i < targets.length; ++i) {
+            this._targetBreakpoints.get(targets[i])._removeFromDebugger();
+            targets[i].debuggerModel.removeEventListener(WebInspector.DebuggerModel.Events.BreakpointResolved, this._breakpointResolved, this);
+        }
+        this._breakpointManager._removeBreakpoint(this, removeFromStorage);
+        this._breakpointManager._targetManager.removeTargetObserver(this);
+    },
+
+    _updateInDebugger: function()
+    {
+        var targetBreakpoints = this._targetBreakpoints.values();
+        for (var i = 0; i < targetBreakpoints.length; ++i)
+            targetBreakpoints[i]._updateInDebugger();
+    },
+
+    /**
+     * @return {string}
+     */
+    _breakpointStorageId: function()
+    {
+        return WebInspector.BreakpointManager._breakpointStorageId(this._sourceFileId, this._lineNumber, this._columnNumber);
+    },
+
+    _fakeBreakpointAtPrimaryLocation: function()
+    {
+        if (this._provisioned || this._isRemoved || !Object.isEmpty(this._numberOfDebuggerLocationForUILocation) || this._fakeBreakpointPrimaryLocation)
+            return;
+
+        var uiSourceCode = this._breakpointManager._workspace.uiSourceCode(this._projectId, this._path);
+        if (!uiSourceCode)
+            return;
+
+        this._fakeBreakpointPrimaryLocation = uiSourceCode.uiLocation(this._lineNumber, this._columnNumber);
+        this._breakpointManager._uiLocationAdded(this, this._fakeBreakpointPrimaryLocation);
+    },
+
+    _removeFakeBreakpointAtPrimaryLocation: function()
+    {
+        if (this._fakeBreakpointPrimaryLocation) {
+            this._breakpointManager._uiLocationRemoved(this, this._fakeBreakpointPrimaryLocation);
+            delete this._fakeBreakpointPrimaryLocation;
+        }
+    },
+
+    /**
+     * @param {!WebInspector.Event} event
+     */
+    _breakpointResolved: function(event)
+    {
+        var breakpointId = /** @type {!DebuggerAgent.BreakpointId} */ (event.data.breakpointId);
+        var location = /** @type {!WebInspector.DebuggerModel.Location} */ (event.data.location);
+        this._targetBreakpoints.get(location.target())._breakpointResolved(breakpointId, location);
+    },
+
+    _resetLocations: function()
+    {
+        this._removeFakeBreakpointAtPrimaryLocation();
+        var targetBreakpoints = this._targetBreakpoints.values();
+        for (var i = 0; i < targetBreakpoints.length; ++i)
+            targetBreakpoints[i]._resetLocations();
+    }
+}
+
+/**
+ * @constructor
+ * @extends {WebInspector.TargetAware}
+ * @param {!WebInspector.Target} target
+ * @param {!WebInspector.BreakpointManager.Breakpoint} breakpoint
+ */
+WebInspector.BreakpointManager.TargetBreakpoint = function(target, breakpoint)
+{
+    WebInspector.TargetAware.call(this, target);
+    this._breakpoint = breakpoint;
+    /** @type {!Array.<!WebInspector.Script.Location>} */
+    this._liveLocations = [];
+
+    /** @type {!Object.<string, !WebInspector.UILocation>} */
+    this._uiLocations = {};
+}
+
+WebInspector.BreakpointManager.TargetBreakpoint.prototype = {
+
+    _resetLocations: function()
+    {
+        var uiLocations = Object.values(this._uiLocations);
+        for (var i = 0; i < uiLocations.length; ++i)
+            this._breakpoint._removeUILocation(uiLocations[i]);
+
+        this._uiLocations = {};
+
+        for (var i = 0; i < this._liveLocations.length; ++i)
+            this._liveLocations[i].dispose();
+        this._liveLocations = [];
+    },
+
+    /**
+     * @param {boolean=} muteCallback
+     */
+    _removeFromDebugger: function(muteCallback)
+    {
+        this._resetLocations();
+        if (!this._debuggerId)
+            return;
+        this.target().debuggerModel.removeBreakpoint(this._debuggerId, muteCallback ? undefined : this._didRemoveFromDebugger.bind(this));
+    },
+
+    _updateInDebugger: function()
+    {
         this._removeFromDebugger();
-        this._breakpointManager._removeBreakpoint(this, removeFromStorage);
-    },
-
-    _updateInDebugger: function()
-    {
-        this._removeFromDebugger();
-        this._fakeBreakpointAtPrimaryLocation();
-        var uiSourceCode = this.uiSourceCode();
-        if (!uiSourceCode || !this._enabled)
-            return;
-
-        var targets = this._breakpointManager._targetManager.targets();
-        for (var i = 0; i < targets.length; ++i) {
-            var scriptFile = uiSourceCode.scriptFileForTarget(targets[i]);
-            if (scriptFile && scriptFile.hasDivergedFromVM())
-                return;
-        }
-
-        for (var i = 0; i < targets.length; ++i) {
-            var rawLocation = uiSourceCode.uiLocationToRawLocation(targets[i], this._lineNumber, this._columnNumber);
-            var debuggerModelLocation = /** @type {!WebInspector.DebuggerModel.Location} */ (rawLocation);
-            if (debuggerModelLocation)
-                targets[i].debuggerModel.setBreakpointByScriptLocation(debuggerModelLocation, this._condition, this._didSetBreakpointInDebugger.bind(this));
-            else if (uiSourceCode.url)
-                targets[i].debuggerModel.setBreakpointByURL(uiSourceCode.url, this._lineNumber, this._columnNumber, this._condition, this._didSetBreakpointInDebugger.bind(this));
-        }
-    },
-
-    /**
-    * @param {?DebuggerAgent.BreakpointId} breakpointId
-    * @param {!Array.<!WebInspector.DebuggerModel.Location>} locations
-    */
+        var uiSourceCode = this._breakpoint.uiSourceCode();
+        if (!uiSourceCode || !this._breakpoint._enabled)
+            return;
+        var scriptFile = uiSourceCode.scriptFileForTarget(this._target);
+        if (scriptFile && scriptFile.hasDivergedFromVM())
+            return;
+
+        var lineNumber = this._breakpoint._lineNumber;
+        var columnNumber = this._breakpoint._columnNumber;
+        var rawLocation = uiSourceCode.uiLocationToRawLocation(this._target, lineNumber, columnNumber);
+        var debuggerModelLocation = /** @type {!WebInspector.DebuggerModel.Location} */ (rawLocation);
+        var condition = this._breakpoint.condition();
+        if (debuggerModelLocation)
+            this.target().debuggerModel.setBreakpointByScriptLocation(debuggerModelLocation, condition, this._didSetBreakpointInDebugger.bind(this));
+        else if (uiSourceCode.url)
+            this.target().debuggerModel.setBreakpointByURL(uiSourceCode.url, lineNumber, columnNumber, condition, this._didSetBreakpointInDebugger.bind(this));
+    },
+
+    /**
+     * @param {?DebuggerAgent.BreakpointId} breakpointId
+     * @param {!Array.<!WebInspector.DebuggerModel.Location>} locations
+     */
     _didSetBreakpointInDebugger: function(breakpointId, locations)
     {
         if (!breakpointId) {
-            this.remove(true);
-            return;
-        }
+            this._breakpoint.remove(true);
+            return;
+        }
+
+        if (this._debuggerId)
+            this._removeFromDebugger(true);
 
         this._debuggerId = breakpointId;
-        this._breakpointManager._breakpointForDebuggerId[breakpointId] = this;
-
         for (var i = 0; i < locations.length; ++i)
             if (!this._addResolvedLocation(locations[i]))
                 return;
     },
 
-    _removeFromDebugger: function()
-    {
-        this._resetLocations();
-        if (!this._debuggerId)
-            return;
-        var barrier = new CallbackBarrier();
-        this._breakpointManager._targetManager.targets().forEach(function(target){target.debuggerModel.removeBreakpoint(this._debuggerId, barrier.createCallback())}, this);
-        barrier.callWhenDone(this._didRemoveFromDebugger.bind(this));
-    },
-
     _didRemoveFromDebugger: function()
     {
-        delete this._breakpointManager._breakpointForDebuggerId[this._debuggerId];
         delete this._debuggerId;
     },
 
-    _resetLocations: function()
-    {
-        for (var stringifiedLocation in this._uiLocations) {
-            var uiLocation = this._uiLocations[stringifiedLocation];
-            if (this._numberOfDebuggerLocationForUILocation[uiLocation.id()]) {
-                this._breakpointManager._uiLocationRemoved(this, uiLocation);
-                delete this._numberOfDebuggerLocationForUILocation[uiLocation.id()];
-            }
-        }
-        if (this._uiLocations[""])
-            this._breakpointManager._uiLocationRemoved(this, this._uiLocations[""]);
-        for (var i = 0; i < this._liveLocations.length; ++i)
-            this._liveLocations[i].dispose();
-        this._liveLocations = [];
-        this._uiLocations = {};
-        this._numberOfDebuggerLocationForUILocation = {};
-    },
-
-    /**
-     * @return {string}
-     */
-    _breakpointStorageId: function()
-    {
-        return WebInspector.BreakpointManager._breakpointStorageId(this._sourceFileId, this._lineNumber, this._columnNumber);
-    },
-
-    _fakeBreakpointAtPrimaryLocation: function()
-    {
-        var uiSourceCode = this._breakpointManager._workspace.uiSourceCode(this._projectId, this._path);
-        if (!uiSourceCode)
-            return;
-        var uiLocation = uiSourceCode.uiLocation(this._lineNumber, this._columnNumber);
-        this._uiLocations[""] = uiLocation;
-        this._breakpointManager._uiLocationAdded(this, uiLocation);
-    }
+    /**
+     * @param {!DebuggerAgent.BreakpointId} breakpointId
+     * @param {!WebInspector.DebuggerModel.Location} location
+     */
+    _breakpointResolved: function(breakpointId, location)
+    {
+        if (this._debuggerId === breakpointId)
+            this._addResolvedLocation(location);
+    },
+
+    /**
+     * @param {!WebInspector.DebuggerModel.Location} location
+     * @param {!WebInspector.UILocation} uiLocation
+     */
+    _locationUpdated: function(location, uiLocation)
+    {
+        var oldUILocation = this._uiLocations[location.id()] || null;
+        this._uiLocations[location.id()] = uiLocation;
+        this._breakpoint._replaceUILocation(oldUILocation, uiLocation);
+    },
+
+    /**
+     * @param {!WebInspector.DebuggerModel.Location} location
+     * @return {boolean}
+     */
+    _addResolvedLocation: function(location)
+    {
+        var script = location.script();
+        var uiLocation = script.rawLocationToUILocation(location.lineNumber, location.columnNumber);
+        var breakpoint = this._breakpoint._breakpointManager.findBreakpoint(uiLocation.uiSourceCode, uiLocation.lineNumber, uiLocation.columnNumber);
+        if (breakpoint && breakpoint != this._breakpoint) {
+            // location clash
+            this._breakpoint.remove();
+            return false;
+        }
+        this._liveLocations.push(location.createLiveLocation(this._locationUpdated.bind(this, location)));
+        return true;
+    },
+
+    __proto__: WebInspector.TargetAware.prototype
 }
 
 /**
  * @constructor
  * @param {!WebInspector.BreakpointManager} breakpointManager
  * @param {!WebInspector.Setting} setting
  */
 WebInspector.BreakpointManager.Storage = function(breakpointManager, setting)
 {
     this._breakpointManager = breakpointManager;
@@ skipping 74 matching lines @@
 {
     this.sourceFileId = breakpoint._sourceFileId;
     this.lineNumber = breakpoint.lineNumber();
     this.columnNumber = breakpoint.columnNumber();
     this.condition = breakpoint.condition();
     this.enabled = breakpoint.enabled();
 }
 
 /** @type {!WebInspector.BreakpointManager} */
 WebInspector.breakpointManager;