DevTools: cleanup breakpointManager after removal of NetworkMapping

third_party/WebKit/Source/devtools/front_end/bindings/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 43 matching lines @@
     this._provisionalBreakpoints = new Multimap();
 
     this._workspace.addEventListener(Workspace.Workspace.Events.ProjectRemoved, this._projectRemoved, this);
     this._workspace.addEventListener(Workspace.Workspace.Events.UISourceCodeAdded, this._uiSourceCodeAdded, this);
     this._workspace.addEventListener(Workspace.Workspace.Events.UISourceCodeRemoved, this._uiSourceCodeRemoved, this);
 
     targetManager.observeTargets(this, SDK.Target.Capability.JS);
   }
 
   /**
-   * @param {string} sourceFileId
+   * @param {string} url
    * @param {number} lineNumber
    * @param {number} columnNumber
    * @return {string}
    */
-  static _breakpointStorageId(sourceFileId, lineNumber, columnNumber) {
-    if (!sourceFileId)
+  static _breakpointStorageId(url, lineNumber, columnNumber) {
+    if (!url)
       return '';
-    return sourceFileId + ':' + lineNumber + ':' + columnNumber;
+    return url + ':' + lineNumber + ':' + columnNumber;
   }
 
   /**
-   * @param {!Workspace.UISourceCode} uiSourceCode
-   * @return {string}
-   */
-  _sourceFileId(uiSourceCode) {
-    // TODO(lushnikov): _sourceFileId is not needed any more.
-    return uiSourceCode.url();
-  }
-
-  /**
    * @override
    * @param {!SDK.Target} target
    */
   targetAdded(target) {
     var debuggerModel = SDK.DebuggerModel.fromTarget(target);
     if (debuggerModel && !this._breakpointsActive)
       debuggerModel.setBreakpointsActive(this._breakpointsActive);
   }
 
   /**
    * @override
    * @param {!SDK.Target} target
    */
   targetRemoved(target) {
   }
 
   /**
-   * @param {string} sourceFileId
+   * @param {string} url
    * @return {!Map.<string, !Bindings.BreakpointManager.Breakpoint>}
    */
-  _provisionalBreakpointsForSourceFileId(sourceFileId) {
+  _provisionalBreakpointsForURL(url) {
     var result = new Map();
-    var breakpoints = this._provisionalBreakpoints.get(sourceFileId).valuesArray();
+    var breakpoints = this._provisionalBreakpoints.get(url).valuesArray();
     for (var i = 0; i < breakpoints.length; ++i)
       result.set(breakpoints[i]._breakpointStorageId(), breakpoints[i]);
     return result;
   }
 
   removeProvisionalBreakpointsForTest() {
     var breakpoints = this._provisionalBreakpoints.valuesArray();
     for (var i = 0; i < breakpoints.length; ++i)
       breakpoints[i].remove();
     this._provisionalBreakpoints.clear();
   }
 
   /**
    * @param {!Workspace.UISourceCode} uiSourceCode
    */
   _restoreBreakpoints(uiSourceCode) {
-    var sourceFileId = this._sourceFileId(uiSourceCode);
-    if (!sourceFileId)
+    var url = uiSourceCode.url();
+    if (!url)
       return;
 
     this._storage.mute();
-    var breakpointItems = this._storage.breakpointItems(this._sourceFileId(uiSourceCode));
-    var provisionalBreakpoints = this._provisionalBreakpointsForSourceFileId(sourceFileId);
+    var breakpointItems = this._storage.breakpointItems(url);
+    var provisionalBreakpoints = this._provisionalBreakpointsForURL(url);
     for (var i = 0; i < breakpointItems.length; ++i) {
       var breakpointItem = breakpointItems[i];
       var itemStorageId = Bindings.BreakpointManager._breakpointStorageId(
-          breakpointItem.sourceFileId, breakpointItem.lineNumber, breakpointItem.columnNumber);
+          breakpointItem.url, breakpointItem.lineNumber, breakpointItem.columnNumber);
       var provisionalBreakpoint = provisionalBreakpoints.get(itemStorageId);
       if (provisionalBreakpoint) {
         if (!this._breakpointsForPrimaryUISourceCode.get(uiSourceCode))
           this._breakpointsForPrimaryUISourceCode.set(uiSourceCode, []);
         this._breakpointsForPrimaryUISourceCode.get(uiSourceCode).push(provisionalBreakpoint);
         provisionalBreakpoint._updateBreakpoint();
       } else {
         this._innerSetBreakpoint(
             uiSourceCode, breakpointItem.lineNumber, breakpointItem.columnNumber, breakpointItem.condition,
             breakpointItem.enabled);
       }
     }
-    this._provisionalBreakpoints.removeAll(sourceFileId);
+    this._provisionalBreakpoints.removeAll(url);
     this._storage.unmute();
   }
 
   /**
    * @param {!Common.Event} event
    */
   _uiSourceCodeAdded(event) {
     var uiSourceCode = /** @type {!Workspace.UISourceCode} */ (event.data);
     this._restoreBreakpoints(uiSourceCode);
     if (uiSourceCode.contentType().hasScripts()) {
@@ skipping 22 matching lines @@
     var breakpoints = this._breakpointsForPrimaryUISourceCode.get(uiSourceCode) || [];
     for (var i = 0; i < breakpoints.length; ++i)
       breakpoints[i]._updateInDebuggerForTarget(target);
   }
 
   /**
    * @param {!Workspace.UISourceCode} uiSourceCode
    */
   _removeUISourceCode(uiSourceCode) {
     var breakpoints = this._breakpointsForPrimaryUISourceCode.get(uiSourceCode) || [];
-    var sourceFileId = this._sourceFileId(uiSourceCode);
     for (var i = 0; i < breakpoints.length; ++i) {
       breakpoints[i]._resetLocations();
       if (breakpoints[i].enabled())
-        this._provisionalBreakpoints.set(sourceFileId, breakpoints[i]);
+        this._provisionalBreakpoints.set(uiSourceCode.url(), breakpoints[i]);
     }
     uiSourceCode.removeEventListener(
         Workspace.UISourceCode.Events.SourceMappingChanged, this._uiSourceCodeMappingChanged, this);
     this._breakpointsForPrimaryUISourceCode.remove(uiSourceCode);
   }
 
   /**
    * @param {!Workspace.UISourceCode} uiSourceCode
    * @param {number} lineNumber
    * @param {number} columnNumber
@@ skipping 21 matching lines @@
    * @param {boolean} enabled
    * @return {!Bindings.BreakpointManager.Breakpoint}
    */
   _innerSetBreakpoint(uiSourceCode, lineNumber, columnNumber, condition, enabled) {
     var breakpoint = this.findBreakpoint(uiSourceCode, lineNumber, columnNumber);
     if (breakpoint) {
       breakpoint._updateState(condition, enabled);
       return breakpoint;
     }
     var projectId = uiSourceCode.project().id();
-    var path = uiSourceCode.url();
-    var sourceFileId = this._sourceFileId(uiSourceCode);
     breakpoint = new Bindings.BreakpointManager.Breakpoint(
-        this, projectId, path, sourceFileId, lineNumber, columnNumber, condition, enabled);
+        this, projectId, uiSourceCode.url(), lineNumber, columnNumber, condition, enabled);
     if (!this._breakpointsForPrimaryUISourceCode.get(uiSourceCode))
       this._breakpointsForPrimaryUISourceCode.set(uiSourceCode, []);
     this._breakpointsForPrimaryUISourceCode.get(uiSourceCode).push(breakpoint);
     return breakpoint;
   }
 
   /**
    * @param {!Workspace.UISourceCode} uiSourceCode
    * @param {number} lineNumber
    * @return {!Array<!Bindings.BreakpointManager.Breakpoint>}
@@ skipping 151 matching lines @@
   /**
    * @param {!Bindings.BreakpointManager.Breakpoint} breakpoint
    * @param {boolean} removeFromStorage
    */
   _removeBreakpoint(breakpoint, removeFromStorage) {
     var uiSourceCode = breakpoint.uiSourceCode();
     var breakpoints = uiSourceCode ? this._breakpointsForPrimaryUISourceCode.get(uiSourceCode) || [] : [];
     breakpoints.remove(breakpoint);
     if (removeFromStorage)
       this._storage._removeBreakpoint(breakpoint);
-    this._provisionalBreakpoints.remove(breakpoint._sourceFileId, breakpoint);
+    this._provisionalBreakpoints.remove(breakpoint._url, breakpoint);
   }
 
   /**
    * @param {!Bindings.BreakpointManager.Breakpoint} breakpoint
    * @param {!Workspace.UILocation} uiLocation
    */
   _uiLocationAdded(breakpoint, uiLocation) {
     var breakpoints = this._breakpointsForUISourceCode.get(uiLocation.uiSourceCode);
     if (!breakpoints) {
       breakpoints = new Map();
@@ skipping 72 matching lines @@
 
 
 /**
  * @implements {SDK.TargetManager.Observer}
  * @unrestricted
  */
 Bindings.BreakpointManager.Breakpoint = class {
   /**
    * @param {!Bindings.BreakpointManager} breakpointManager
    * @param {string} projectId
-   * @param {string} path
-   * @param {string} sourceFileId
+   * @param {string} url
    * @param {number} lineNumber
    * @param {number} columnNumber
    * @param {string} condition
    * @param {boolean} enabled
    */
-  constructor(breakpointManager, projectId, path, sourceFileId, lineNumber, columnNumber, condition, enabled) {
+  constructor(breakpointManager, projectId, url, lineNumber, columnNumber, condition, enabled) {
     this._breakpointManager = breakpointManager;
     this._projectId = projectId;
-    this._path = path;
+    this._url = url;
     this._lineNumber = lineNumber;
     this._columnNumber = columnNumber;
-    this._sourceFileId = sourceFileId;
 
     /** @type {!Map<string, number>} */
     this._numberOfDebuggerLocationForUILocation = new Map();
 
     // Force breakpoint update.
     /** @type {string} */ this._condition;
     /** @type {boolean} */ this._enabled;
     /** @type {boolean} */ this._isRemoved;
     /** @type {!Workspace.UILocation|undefined} */ this._fakePrimaryLocation;
 
@@ skipping 33 matching lines @@
   /**
    * @return {string}
    */
   projectId() {
     return this._projectId;
   }
 
   /**
    * @return {string}
    */
-  path() {
-    return this._path;
+  url() {
+    return this._url;
   }
 
   /**
    * @return {number}
    */
   lineNumber() {
     return this._lineNumber;
   }
 
   /**
    * @return {number}
    */
   columnNumber() {
     return this._columnNumber;
   }
 
   /**
    * @return {?Workspace.UISourceCode}
    */
   uiSourceCode() {
-    return this._breakpointManager._workspace.uiSourceCode(this._projectId, this._path);
+    return this._breakpointManager._workspace.uiSourceCode(this._projectId, this._url);
   }
 
   /**
    * @param {?Workspace.UILocation} oldUILocation
    * @param {!Workspace.UILocation} newUILocation
    */
   _replaceUILocation(oldUILocation, newUILocation) {
     if (this._isRemoved)
       return;
 
@@ skipping 94 matching lines @@
    * @param {!SDK.Target} target
    */
   _updateInDebuggerForTarget(target) {
     this._targetBreakpoints.get(target)._scheduleUpdateInDebugger();
   }
 
   /**
    * @return {string}
    */
   _breakpointStorageId() {
-    return Bindings.BreakpointManager._breakpointStorageId(this._sourceFileId, this._lineNumber, this._columnNumber);
+    return Bindings.BreakpointManager._breakpointStorageId(this._url, this._lineNumber, this._columnNumber);
   }
 
   _fakeBreakpointAtPrimaryLocation() {
     if (this._isRemoved || this._numberOfDebuggerLocationForUILocation.size || this._fakePrimaryLocation)
       return;
 
-    var uiSourceCode = this._breakpointManager._workspace.uiSourceCode(this._projectId, this._path);
+    var uiSourceCode = this._breakpointManager._workspace.uiSourceCode(this._projectId, this._url);
     if (!uiSourceCode)
       return;
 
     this._fakePrimaryLocation = uiSourceCode.uiLocation(this._lineNumber, this._columnNumber);
     if (this._fakePrimaryLocation)
       this._breakpointManager._uiLocationAdded(this, this._fakePrimaryLocation);
   }
 
   _removeFakeBreakpointAtPrimaryLocation() {
     if (this._fakePrimaryLocation) {
@@ skipping 294 matching lines @@
    */
   constructor(breakpointManager, setting) {
     this._breakpointManager = breakpointManager;
     this._setting = setting || Common.settings.createLocalSetting('breakpoints', []);
     var breakpoints = this._setting.get();
     /** @type {!Object.<string, !Bindings.BreakpointManager.Storage.Item>} */
     this._breakpoints = {};
     for (var i = 0; i < breakpoints.length; ++i) {
       var breakpoint = /** @type {!Bindings.BreakpointManager.Storage.Item} */ (breakpoints[i]);
       breakpoint.columnNumber = breakpoint.columnNumber || 0;
-      this._breakpoints[breakpoint.sourceFileId + ':' + breakpoint.lineNumber + ':' + breakpoint.columnNumber] =
-          breakpoint;
+      this._breakpoints[breakpoint.url + ':' + breakpoint.lineNumber + ':' + breakpoint.columnNumber] = breakpoint;
     }
   }
 
   mute() {
     this._muted = true;
   }
 
   unmute() {
     delete this._muted;
   }
 
   /**
-   * @param {string} sourceFileId
+   * @param {string} url
    * @return {!Array.<!Bindings.BreakpointManager.Storage.Item>}
    */
-  breakpointItems(sourceFileId) {
+  breakpointItems(url) {
     var result = [];
     for (var id in this._breakpoints) {
       var breakpoint = this._breakpoints[id];
-      if (breakpoint.sourceFileId === sourceFileId)
+      if (breakpoint.url === url)
         result.push(breakpoint);
     }
     return result;
   }
 
   /**
    * @param {!Bindings.BreakpointManager.Breakpoint} breakpoint
    */
   _updateBreakpoint(breakpoint) {
     if (this._muted || !breakpoint._breakpointStorageId())
@@ skipping 21 matching lines @@
 };
 
 /**
  * @unrestricted
  */
 Bindings.BreakpointManager.Storage.Item = class {
   /**
    * @param {!Bindings.BreakpointManager.Breakpoint} breakpoint
    */
   constructor(breakpoint) {
-    this.sourceFileId = breakpoint._sourceFileId;
+    this.url = breakpoint._url;
     this.lineNumber = breakpoint.lineNumber();
     this.columnNumber = breakpoint.columnNumber();
     this.condition = breakpoint.condition();
     this.enabled = breakpoint.enabled();
   }
 };
 
 /** @type {!Bindings.BreakpointManager} */
 Bindings.breakpointManager;