DevTools: rename WebInspector into modules.

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 10 matching lines @@
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * OWNER OR 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.
  */
 /**
- * @implements {WebInspector.TargetManager.Observer}
+ * @implements {SDK.TargetManager.Observer}
  * @unrestricted
  */
-WebInspector.BreakpointManager = class extends WebInspector.Object {
+Bindings.BreakpointManager = class extends Common.Object {
   /**
-   * @param {?WebInspector.Setting} breakpointsSetting
-   * @param {!WebInspector.Workspace} workspace
-   * @param {!WebInspector.TargetManager} targetManager
-   * @param {!WebInspector.DebuggerWorkspaceBinding} debuggerWorkspaceBinding
+   * @param {?Common.Setting} breakpointsSetting
+   * @param {!Workspace.Workspace} workspace
+   * @param {!SDK.TargetManager} targetManager
+   * @param {!Bindings.DebuggerWorkspaceBinding} debuggerWorkspaceBinding
    */
   constructor(breakpointsSetting, workspace, targetManager, debuggerWorkspaceBinding) {
     super();
-    this._storage = new WebInspector.BreakpointManager.Storage(this, breakpointsSetting);
+    this._storage = new Bindings.BreakpointManager.Storage(this, breakpointsSetting);
     this._workspace = workspace;
     this._targetManager = targetManager;
     this._debuggerWorkspaceBinding = debuggerWorkspaceBinding;
 
     this._breakpointsActive = true;
-    /** @type {!Map<!WebInspector.UISourceCode, !Map<number, !Map<number, !Array<!WebInspector.BreakpointManager.Breakpoint>>>>} */
+    /** @type {!Map<!Workspace.UISourceCode, !Map<number, !Map<number, !Array<!Bindings.BreakpointManager.Breakpoint>>>>} */
     this._breakpointsForUISourceCode = new Map();
-    /** @type {!Map<!WebInspector.UISourceCode, !Array<!WebInspector.BreakpointManager.Breakpoint>>} */
+    /** @type {!Map<!Workspace.UISourceCode, !Array<!Bindings.BreakpointManager.Breakpoint>>} */
     this._breakpointsForPrimaryUISourceCode = new Map();
-    /** @type {!Multimap.<string, !WebInspector.BreakpointManager.Breakpoint>} */
+    /** @type {!Multimap.<string, !Bindings.BreakpointManager.Breakpoint>} */
     this._provisionalBreakpoints = new Multimap();
 
-    this._workspace.addEventListener(WebInspector.Workspace.Events.ProjectRemoved, this._projectRemoved, this);
-    this._workspace.addEventListener(WebInspector.Workspace.Events.UISourceCodeAdded, this._uiSourceCodeAdded, this);
+    this._workspace.addEventListener(Workspace.Workspace.Events.ProjectRemoved, this._projectRemoved, this);
+    this._workspace.addEventListener(Workspace.Workspace.Events.UISourceCodeAdded, this._uiSourceCodeAdded, this);
     this._workspace.addEventListener(
-        WebInspector.Workspace.Events.UISourceCodeRemoved, this._uiSourceCodeRemoved, this);
+        Workspace.Workspace.Events.UISourceCodeRemoved, this._uiSourceCodeRemoved, this);
 
-    targetManager.observeTargets(this, WebInspector.Target.Capability.JS);
+    targetManager.observeTargets(this, SDK.Target.Capability.JS);
   }
 
   /**
    * @param {string} sourceFileId
    * @param {number} lineNumber
    * @param {number} columnNumber
    * @return {string}
    */
   static _breakpointStorageId(sourceFileId, lineNumber, columnNumber) {
     if (!sourceFileId)
       return '';
     return sourceFileId + ':' + lineNumber + ':' + columnNumber;
   }
 
   /**
-   * @param {!WebInspector.UISourceCode} uiSourceCode
+   * @param {!Workspace.UISourceCode} uiSourceCode
    * @return {string}
    */
   _sourceFileId(uiSourceCode) {
     // TODO(lushnikov): _sourceFileId is not needed any more.
     return uiSourceCode.url();
   }
 
   /**
    * @override
-   * @param {!WebInspector.Target} target
+   * @param {!SDK.Target} target
    */
   targetAdded(target) {
-    var debuggerModel = WebInspector.DebuggerModel.fromTarget(target);
+    var debuggerModel = SDK.DebuggerModel.fromTarget(target);
     if (debuggerModel && !this._breakpointsActive)
       debuggerModel.setBreakpointsActive(this._breakpointsActive);
   }
 
   /**
    * @override
-   * @param {!WebInspector.Target} target
+   * @param {!SDK.Target} target
    */
   targetRemoved(target) {
   }
 
   /**
    * @param {string} sourceFileId
-   * @return {!Map.<string, !WebInspector.BreakpointManager.Breakpoint>}
+   * @return {!Map.<string, !Bindings.BreakpointManager.Breakpoint>}
    */
   _provisionalBreakpointsForSourceFileId(sourceFileId) {
     var result = new Map();
     var breakpoints = this._provisionalBreakpoints.get(sourceFileId).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 {!WebInspector.UISourceCode} uiSourceCode
+   * @param {!Workspace.UISourceCode} uiSourceCode
    */
   _restoreBreakpoints(uiSourceCode) {
     var sourceFileId = this._sourceFileId(uiSourceCode);
     if (!sourceFileId)
       return;
 
     this._storage.mute();
     var breakpointItems = this._storage.breakpointItems(this._sourceFileId(uiSourceCode));
     var provisionalBreakpoints = this._provisionalBreakpointsForSourceFileId(sourceFileId);
     for (var i = 0; i < breakpointItems.length; ++i) {
       var breakpointItem = breakpointItems[i];
-      var itemStorageId = WebInspector.BreakpointManager._breakpointStorageId(
+      var itemStorageId = Bindings.BreakpointManager._breakpointStorageId(
           breakpointItem.sourceFileId, 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._storage.unmute();
   }
 
   /**
-   * @param {!WebInspector.Event} event
+   * @param {!Common.Event} event
    */
   _uiSourceCodeAdded(event) {
-    var uiSourceCode = /** @type {!WebInspector.UISourceCode} */ (event.data);
+    var uiSourceCode = /** @type {!Workspace.UISourceCode} */ (event.data);
     this._restoreBreakpoints(uiSourceCode);
     if (uiSourceCode.contentType().hasScripts()) {
       uiSourceCode.addEventListener(
-          WebInspector.UISourceCode.Events.SourceMappingChanged, this._uiSourceCodeMappingChanged, this);
+          Workspace.UISourceCode.Events.SourceMappingChanged, this._uiSourceCodeMappingChanged, this);
     }
   }
 
   /**
-   * @param {!WebInspector.Event} event
+   * @param {!Common.Event} event
    */
   _uiSourceCodeRemoved(event) {
-    var uiSourceCode = /** @type {!WebInspector.UISourceCode} */ (event.data);
+    var uiSourceCode = /** @type {!Workspace.UISourceCode} */ (event.data);
     this._removeUISourceCode(uiSourceCode);
   }
 
   /**
-   * @param {!WebInspector.Event} event
+   * @param {!Common.Event} event
    */
   _uiSourceCodeMappingChanged(event) {
-    var uiSourceCode = /** @type {!WebInspector.UISourceCode} */ (event.target);
+    var uiSourceCode = /** @type {!Workspace.UISourceCode} */ (event.target);
     var isIdentity = /** @type {boolean} */ (event.data.isIdentity);
-    var target = /** @type {!WebInspector.Target} */ (event.data.target);
+    var target = /** @type {!SDK.Target} */ (event.data.target);
     if (isIdentity)
       return;
     var breakpoints = this._breakpointsForPrimaryUISourceCode.get(uiSourceCode) || [];
     for (var i = 0; i < breakpoints.length; ++i)
       breakpoints[i]._updateInDebuggerForTarget(target);
   }
 
   /**
-   * @param {!WebInspector.UISourceCode} uiSourceCode
+   * @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]);
     }
     uiSourceCode.removeEventListener(
-        WebInspector.UISourceCode.Events.SourceMappingChanged, this._uiSourceCodeMappingChanged, this);
+        Workspace.UISourceCode.Events.SourceMappingChanged, this._uiSourceCodeMappingChanged, this);
     this._breakpointsForPrimaryUISourceCode.remove(uiSourceCode);
   }
 
   /**
-   * @param {!WebInspector.UISourceCode} uiSourceCode
+   * @param {!Workspace.UISourceCode} uiSourceCode
    * @param {number} lineNumber
    * @param {number} columnNumber
    * @param {string} condition
    * @param {boolean} enabled
-   * @return {!WebInspector.BreakpointManager.Breakpoint}
+   * @return {!Bindings.BreakpointManager.Breakpoint}
    */
   setBreakpoint(uiSourceCode, lineNumber, columnNumber, condition, enabled) {
-    var uiLocation = new WebInspector.UILocation(uiSourceCode, lineNumber, columnNumber);
+    var uiLocation = new Workspace.UILocation(uiSourceCode, lineNumber, columnNumber);
     var normalizedLocation = this._debuggerWorkspaceBinding.normalizeUILocation(uiLocation);
     if (normalizedLocation.id() !== uiLocation.id()) {
-      WebInspector.Revealer.reveal(normalizedLocation);
+      Common.Revealer.reveal(normalizedLocation);
       uiLocation = normalizedLocation;
     }
     this.setBreakpointsActive(true);
     return this._innerSetBreakpoint(
         uiLocation.uiSourceCode, uiLocation.lineNumber, uiLocation.columnNumber, condition, enabled);
   }
 
   /**
-   * @param {!WebInspector.UISourceCode} uiSourceCode
+   * @param {!Workspace.UISourceCode} uiSourceCode
    * @param {number} lineNumber
    * @param {number} columnNumber
    * @param {string} condition
    * @param {boolean} enabled
-   * @return {!WebInspector.BreakpointManager.Breakpoint}
+   * @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 WebInspector.BreakpointManager.Breakpoint(
+    breakpoint = new Bindings.BreakpointManager.Breakpoint(
         this, projectId, path, sourceFileId, lineNumber, columnNumber, condition, enabled);
     if (!this._breakpointsForPrimaryUISourceCode.get(uiSourceCode))
       this._breakpointsForPrimaryUISourceCode.set(uiSourceCode, []);
     this._breakpointsForPrimaryUISourceCode.get(uiSourceCode).push(breakpoint);
     return breakpoint;
   }
 
   /**
-   * @param {!WebInspector.UISourceCode} uiSourceCode
+   * @param {!Workspace.UISourceCode} uiSourceCode
    * @param {number} lineNumber
-   * @return {!Array<!WebInspector.BreakpointManager.Breakpoint>}
+   * @return {!Array<!Bindings.BreakpointManager.Breakpoint>}
    */
   findBreakpoints(uiSourceCode, lineNumber) {
     var breakpoints = this._breakpointsForUISourceCode.get(uiSourceCode);
     var lineBreakpoints = breakpoints ? breakpoints.get(lineNumber) : null;
     return lineBreakpoints ? lineBreakpoints.valuesArray()[0] : [];
   }
 
   /**
-   * @param {!WebInspector.UISourceCode} uiSourceCode
+   * @param {!Workspace.UISourceCode} uiSourceCode
    * @param {number} lineNumber
    * @param {number} columnNumber
-   * @return {?WebInspector.BreakpointManager.Breakpoint}
+   * @return {?Bindings.BreakpointManager.Breakpoint}
    */
   findBreakpoint(uiSourceCode, lineNumber, columnNumber) {
     var breakpoints = this._breakpointsForUISourceCode.get(uiSourceCode);
     var lineBreakpoints = breakpoints ? breakpoints.get(lineNumber) : null;
     var columnBreakpoints = lineBreakpoints ? lineBreakpoints.get(columnNumber) : null;
     return columnBreakpoints ? columnBreakpoints[0] : null;
   }
 
   /**
-   * @param {!WebInspector.UISourceCode} uiSourceCode
-   * @param {!WebInspector.TextRange} textRange
-   * @return {!Promise<!Array<!WebInspector.UILocation>>}
+   * @param {!Workspace.UISourceCode} uiSourceCode
+   * @param {!Common.TextRange} textRange
+   * @return {!Promise<!Array<!Workspace.UILocation>>}
    */
   possibleBreakpoints(uiSourceCode, textRange) {
-    var targets = this._targetManager.targets(WebInspector.Target.Capability.JS);
+    var targets = this._targetManager.targets(SDK.Target.Capability.JS);
     if (!targets.length)
       return Promise.resolve([]);
     for (var target of targets) {
       var startLocation = this._debuggerWorkspaceBinding.uiLocationToRawLocation(target, uiSourceCode, textRange.startLine, textRange.startColumn);
       if (!startLocation)
         continue;
       var endLocation = this._debuggerWorkspaceBinding.uiLocationToRawLocation(target, uiSourceCode, textRange.endLine, textRange.endColumn);
       if (!endLocation)
         continue;
-      var debuggerModel = WebInspector.DebuggerModel.fromTarget(target);
+      var debuggerModel = SDK.DebuggerModel.fromTarget(target);
       return debuggerModel.getPossibleBreakpoints(startLocation, endLocation).then(toUILocations.bind(this));
     }
     return Promise.resolve([]);
 
     /**
-     * @this {!WebInspector.BreakpointManager}
-     * @param {!Array<!WebInspector.DebuggerModel.Location>} locations
-     * @return {!Array<!WebInspector.UILocation>}
+     * @this {!Bindings.BreakpointManager}
+     * @param {!Array<!SDK.DebuggerModel.Location>} locations
+     * @return {!Array<!Workspace.UILocation>}
      */
     function toUILocations(locations) {
       var sortedLocations = locations.map(location => this._debuggerWorkspaceBinding.rawLocationToUILocation(location));
       sortedLocations = sortedLocations.filter(location => location && location.uiSourceCode === uiSourceCode);
-      sortedLocations.sort(WebInspector.UILocation.comparator);
+      sortedLocations.sort(Workspace.UILocation.comparator);
       if (!sortedLocations.length)
         return [];
       var result = [ sortedLocations[0] ];
       var lastLocation = sortedLocations[0];
       for (var i = 1; i < sortedLocations.length; ++i) {
         if (sortedLocations[i].id() === lastLocation.id())
           continue;
         result.push(sortedLocations[i]);
         lastLocation = sortedLocations[i];
       }
       return result;
     }
   }
 
   /**
-   * @param {!WebInspector.UISourceCode} uiSourceCode
-   * @return {!Array.<!WebInspector.BreakpointManager.Breakpoint>}
+   * @param {!Workspace.UISourceCode} uiSourceCode
+   * @return {!Array.<!Bindings.BreakpointManager.Breakpoint>}
    */
   breakpointsForUISourceCode(uiSourceCode) {
     var result = [];
     var uiSourceCodeBreakpoints = this._breakpointsForUISourceCode.get(uiSourceCode);
     var breakpoints = uiSourceCodeBreakpoints ? uiSourceCodeBreakpoints.valuesArray() : [];
     for (var i = 0; i < breakpoints.length; ++i) {
       var lineBreakpoints = breakpoints[i];
       var columnBreakpointArrays = lineBreakpoints ? lineBreakpoints.valuesArray() : [];
       result = result.concat.apply(result, columnBreakpointArrays);
     }
     return result;
   }
 
   /**
-   * @return {!Array.<!WebInspector.BreakpointManager.Breakpoint>}
+   * @return {!Array.<!Bindings.BreakpointManager.Breakpoint>}
    */
   allBreakpoints() {
     var result = [];
     var uiSourceCodes = this._breakpointsForUISourceCode.keysArray();
     for (var i = 0; i < uiSourceCodes.length; ++i)
       result = result.concat(this.breakpointsForUISourceCode(uiSourceCodes[i]));
     return result;
   }
 
   /**
-   * @param {!WebInspector.UISourceCode} uiSourceCode
-   * @return {!Array.<!{breakpoint: !WebInspector.BreakpointManager.Breakpoint, uiLocation: !WebInspector.UILocation}>}
+   * @param {!Workspace.UISourceCode} uiSourceCode
+   * @return {!Array.<!{breakpoint: !Bindings.BreakpointManager.Breakpoint, uiLocation: !Workspace.UILocation}>}
    */
   breakpointLocationsForUISourceCode(uiSourceCode) {
     var uiSourceCodeBreakpoints = this._breakpointsForUISourceCode.get(uiSourceCode);
     var lineNumbers = uiSourceCodeBreakpoints ? uiSourceCodeBreakpoints.keysArray() : [];
     var result = [];
     for (var i = 0; i < lineNumbers.length; ++i) {
       var lineBreakpoints = uiSourceCodeBreakpoints.get(lineNumbers[i]);
       var columnNumbers = lineBreakpoints.keysArray();
       for (var j = 0; j < columnNumbers.length; ++j) {
         var columnBreakpoints = lineBreakpoints.get(columnNumbers[j]);
         var lineNumber = parseInt(lineNumbers[i], 10);
         var columnNumber = parseInt(columnNumbers[j], 10);
         for (var k = 0; k < columnBreakpoints.length; ++k) {
           var breakpoint = columnBreakpoints[k];
           var uiLocation = uiSourceCode.uiLocation(lineNumber, columnNumber);
           result.push({breakpoint: breakpoint, uiLocation: uiLocation});
         }
       }
     }
     return result;
   }
 
   /**
-   * @return {!Array.<!{breakpoint: !WebInspector.BreakpointManager.Breakpoint, uiLocation: !WebInspector.UILocation}>}
+   * @return {!Array.<!{breakpoint: !Bindings.BreakpointManager.Breakpoint, uiLocation: !Workspace.UILocation}>}
    */
   allBreakpointLocations() {
     var result = [];
     var uiSourceCodes = this._breakpointsForUISourceCode.keysArray();
     for (var i = 0; i < uiSourceCodes.length; ++i)
       result = result.concat(this.breakpointLocationsForUISourceCode(uiSourceCodes[i]));
     return result;
   }
 
   /**
    * @param {boolean} toggleState
    */
   toggleAllBreakpoints(toggleState) {
     var breakpoints = this.allBreakpoints();
     for (var i = 0; i < breakpoints.length; ++i)
       breakpoints[i].setEnabled(toggleState);
   }
 
   removeAllBreakpoints() {
     var breakpoints = this.allBreakpoints();
     for (var i = 0; i < breakpoints.length; ++i)
       breakpoints[i].remove();
   }
 
   _projectRemoved(event) {
-    var project = /** @type {!WebInspector.Project} */ (event.data);
+    var project = /** @type {!Workspace.Project} */ (event.data);
     var uiSourceCodes = project.uiSourceCodes();
     for (var i = 0; i < uiSourceCodes.length; ++i)
       this._removeUISourceCode(uiSourceCodes[i]);
   }
 
   /**
-   * @param {!WebInspector.BreakpointManager.Breakpoint} breakpoint
+   * @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);
   }
 
   /**
-   * @param {!WebInspector.BreakpointManager.Breakpoint} breakpoint
-   * @param {!WebInspector.UILocation} uiLocation
+   * @param {!Bindings.BreakpointManager.Breakpoint} breakpoint
+   * @param {!Workspace.UILocation} uiLocation
    */
   _uiLocationAdded(breakpoint, uiLocation) {
     var breakpoints = this._breakpointsForUISourceCode.get(uiLocation.uiSourceCode);
     if (!breakpoints) {
       breakpoints = new Map();
       this._breakpointsForUISourceCode.set(uiLocation.uiSourceCode, breakpoints);
     }
     var lineBreakpoints = breakpoints.get(uiLocation.lineNumber);
     if (!lineBreakpoints) {
       lineBreakpoints = new Map();
       breakpoints.set(uiLocation.lineNumber, lineBreakpoints);
     }
     var columnBreakpoints = lineBreakpoints.get(uiLocation.columnNumber);
     if (!columnBreakpoints) {
       columnBreakpoints = [];
       lineBreakpoints.set(uiLocation.columnNumber, columnBreakpoints);
     }
     columnBreakpoints.push(breakpoint);
     this.dispatchEventToListeners(
-        WebInspector.BreakpointManager.Events.BreakpointAdded, {breakpoint: breakpoint, uiLocation: uiLocation});
+        Bindings.BreakpointManager.Events.BreakpointAdded, {breakpoint: breakpoint, uiLocation: uiLocation});
   }
 
   /**
-   * @param {!WebInspector.BreakpointManager.Breakpoint} breakpoint
-   * @param {!WebInspector.UILocation} uiLocation
+   * @param {!Bindings.BreakpointManager.Breakpoint} breakpoint
+   * @param {!Workspace.UILocation} uiLocation
    */
   _uiLocationRemoved(breakpoint, uiLocation) {
     var breakpoints = this._breakpointsForUISourceCode.get(uiLocation.uiSourceCode);
     if (!breakpoints)
       return;
 
     var lineBreakpoints = breakpoints.get(uiLocation.lineNumber);
     if (!lineBreakpoints)
       return;
     var columnBreakpoints = lineBreakpoints.get(uiLocation.columnNumber);
     if (!columnBreakpoints)
       return;
     columnBreakpoints.remove(breakpoint);
     if (!columnBreakpoints.length)
       lineBreakpoints.remove(uiLocation.columnNumber);
     if (!lineBreakpoints.size)
       breakpoints.remove(uiLocation.lineNumber);
     if (!breakpoints.size)
       this._breakpointsForUISourceCode.remove(uiLocation.uiSourceCode);
     this.dispatchEventToListeners(
-        WebInspector.BreakpointManager.Events.BreakpointRemoved, {breakpoint: breakpoint, uiLocation: uiLocation});
+        Bindings.BreakpointManager.Events.BreakpointRemoved, {breakpoint: breakpoint, uiLocation: uiLocation});
   }
 
   /**
    * @param {boolean} active
    */
   setBreakpointsActive(active) {
     if (this._breakpointsActive === active)
       return;
 
     this._breakpointsActive = active;
-    var debuggerModels = WebInspector.DebuggerModel.instances();
+    var debuggerModels = SDK.DebuggerModel.instances();
     for (var i = 0; i < debuggerModels.length; ++i)
       debuggerModels[i].setBreakpointsActive(active);
 
-    this.dispatchEventToListeners(WebInspector.BreakpointManager.Events.BreakpointsActiveStateChanged, active);
+    this.dispatchEventToListeners(Bindings.BreakpointManager.Events.BreakpointsActiveStateChanged, active);
   }
 
   /**
    * @return {boolean}
    */
   breakpointsActive() {
     return this._breakpointsActive;
   }
 };
 
 /** @enum {symbol} */
-WebInspector.BreakpointManager.Events = {
+Bindings.BreakpointManager.Events = {
   BreakpointAdded: Symbol('breakpoint-added'),
   BreakpointRemoved: Symbol('breakpoint-removed'),
   BreakpointsActiveStateChanged: Symbol('BreakpointsActiveStateChanged')
 };
 
 
 /**
- * @implements {WebInspector.TargetManager.Observer}
+ * @implements {SDK.TargetManager.Observer}
  * @unrestricted
  */
-WebInspector.BreakpointManager.Breakpoint = class {
+Bindings.BreakpointManager.Breakpoint = class {
   /**
-   * @param {!WebInspector.BreakpointManager} breakpointManager
+   * @param {!Bindings.BreakpointManager} breakpointManager
    * @param {string} projectId
    * @param {string} path
    * @param {string} sourceFileId
    * @param {number} lineNumber
    * @param {number} columnNumber
    * @param {string} condition
    * @param {boolean} enabled
    */
   constructor(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 {!Map<string, number>} */
     this._numberOfDebuggerLocationForUILocation = new Map();
 
     // Force breakpoint update.
     /** @type {string} */ this._condition;
     /** @type {boolean} */ this._enabled;
     /** @type {boolean} */ this._isRemoved;
-    /** @type {!WebInspector.UILocation|undefined} */ this._fakePrimaryLocation;
+    /** @type {!Workspace.UILocation|undefined} */ this._fakePrimaryLocation;
 
     this._currentState = null;
-    /** @type {!Map.<!WebInspector.Target, !WebInspector.BreakpointManager.TargetBreakpoint>}*/
+    /** @type {!Map.<!SDK.Target, !Bindings.BreakpointManager.TargetBreakpoint>}*/
     this._targetBreakpoints = new Map();
     this._updateState(condition, enabled);
     this._breakpointManager._targetManager.observeTargets(this);
   }
 
   /**
    * @override
-   * @param {!WebInspector.Target} target
+   * @param {!SDK.Target} target
    */
   targetAdded(target) {
-    var debuggerModel = WebInspector.DebuggerModel.fromTarget(target);
+    var debuggerModel = SDK.DebuggerModel.fromTarget(target);
     if (!debuggerModel)
       return;
     var debuggerWorkspaceBinding = this._breakpointManager._debuggerWorkspaceBinding;
     this._targetBreakpoints.set(
-        target, new WebInspector.BreakpointManager.TargetBreakpoint(debuggerModel, this, debuggerWorkspaceBinding));
+        target, new Bindings.BreakpointManager.TargetBreakpoint(debuggerModel, this, debuggerWorkspaceBinding));
   }
 
   /**
    * @override
-   * @param {!WebInspector.Target} target
+   * @param {!SDK.Target} target
    */
   targetRemoved(target) {
-    var debuggerModel = WebInspector.DebuggerModel.fromTarget(target);
+    var debuggerModel = SDK.DebuggerModel.fromTarget(target);
     if (!debuggerModel)
       return;
     var targetBreakpoint = this._targetBreakpoints.remove(target);
     targetBreakpoint._cleanUpAfterDebuggerIsGone();
     targetBreakpoint._removeEventListeners();
   }
 
   /**
    * @return {string}
    */
@@ skipping 16 matching lines @@
   }
 
   /**
    * @return {number}
    */
   columnNumber() {
     return this._columnNumber;
   }
 
   /**
-   * @return {?WebInspector.UISourceCode}
+   * @return {?Workspace.UISourceCode}
    */
   uiSourceCode() {
     return this._breakpointManager._workspace.uiSourceCode(this._projectId, this._path);
   }
 
   /**
-   * @param {?WebInspector.UILocation} oldUILocation
-   * @param {!WebInspector.UILocation} newUILocation
+   * @param {?Workspace.UILocation} oldUILocation
+   * @param {!Workspace.UILocation} newUILocation
    */
   _replaceUILocation(oldUILocation, newUILocation) {
     if (this._isRemoved)
       return;
 
     this._removeUILocation(oldUILocation, true);
     this._removeFakeBreakpointAtPrimaryLocation();
 
     var current = (this._numberOfDebuggerLocationForUILocation.get(newUILocation.id()) || 0) + 1;
     this._numberOfDebuggerLocationForUILocation.set(newUILocation.id(), current);
     if (current === 1)
       this._breakpointManager._uiLocationAdded(this, newUILocation);
   }
 
   /**
-   * @param {?WebInspector.UILocation} uiLocation
+   * @param {?Workspace.UILocation} uiLocation
    * @param {boolean=} muteCreationFakeBreakpoint
    */
   _removeUILocation(uiLocation, muteCreationFakeBreakpoint) {
     if (!uiLocation || !this._numberOfDebuggerLocationForUILocation.has(uiLocation.id()))
       return;
     var current = (this._numberOfDebuggerLocationForUILocation.get(uiLocation.id()) || 0) - 1;
     this._numberOfDebuggerLocationForUILocation.set(uiLocation.id(), current);
     if (current !== 0)
       return;
 
@@ skipping 63 matching lines @@
     for (var i = 0; i < targetBreakpoints.length; ++i) {
       targetBreakpoints[i]._scheduleUpdateInDebugger();
       targetBreakpoints[i]._removeEventListeners();
     }
 
     this._breakpointManager._removeBreakpoint(this, removeFromStorage);
     this._breakpointManager._targetManager.unobserveTargets(this);
   }
 
   /**
-   * @param {!WebInspector.Target} target
+   * @param {!SDK.Target} target
    */
   _updateInDebuggerForTarget(target) {
     this._targetBreakpoints.get(target)._scheduleUpdateInDebugger();
   }
 
   /**
    * @return {string}
    */
   _breakpointStorageId() {
-    return WebInspector.BreakpointManager._breakpointStorageId(
+    return Bindings.BreakpointManager._breakpointStorageId(
         this._sourceFileId, this._lineNumber, this._columnNumber);
   }
 
   _fakeBreakpointAtPrimaryLocation() {
     if (this._isRemoved || this._numberOfDebuggerLocationForUILocation.size || this._fakePrimaryLocation)
       return;
 
     var uiSourceCode = this._breakpointManager._workspace.uiSourceCode(this._projectId, this._path);
     if (!uiSourceCode)
       return;
@@ skipping 14 matching lines @@
     this._removeFakeBreakpointAtPrimaryLocation();
     var targetBreakpoints = this._targetBreakpoints.valuesArray();
     for (var i = 0; i < targetBreakpoints.length; ++i)
       targetBreakpoints[i]._resetLocations();
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.BreakpointManager.TargetBreakpoint = class extends WebInspector.SDKObject {
+Bindings.BreakpointManager.TargetBreakpoint = class extends SDK.SDKObject {
   /**
-   * @param {!WebInspector.DebuggerModel} debuggerModel
-   * @param {!WebInspector.BreakpointManager.Breakpoint} breakpoint
-   * @param {!WebInspector.DebuggerWorkspaceBinding} debuggerWorkspaceBinding
+   * @param {!SDK.DebuggerModel} debuggerModel
+   * @param {!Bindings.BreakpointManager.Breakpoint} breakpoint
+   * @param {!Bindings.DebuggerWorkspaceBinding} debuggerWorkspaceBinding
    */
   constructor(debuggerModel, breakpoint, debuggerWorkspaceBinding) {
     super(debuggerModel.target());
     this._debuggerModel = debuggerModel;
     this._breakpoint = breakpoint;
     this._debuggerWorkspaceBinding = debuggerWorkspaceBinding;
 
-    this._liveLocations = new WebInspector.LiveLocationPool();
+    this._liveLocations = new Bindings.LiveLocationPool();
 
-    /** @type {!Map<string, !WebInspector.UILocation>} */
+    /** @type {!Map<string, !Workspace.UILocation>} */
     this._uiLocations = new Map();
     this._debuggerModel.addEventListener(
-        WebInspector.DebuggerModel.Events.DebuggerWasDisabled, this._cleanUpAfterDebuggerIsGone, this);
+        SDK.DebuggerModel.Events.DebuggerWasDisabled, this._cleanUpAfterDebuggerIsGone, this);
     this._debuggerModel.addEventListener(
-        WebInspector.DebuggerModel.Events.DebuggerWasEnabled, this._scheduleUpdateInDebugger, this);
+        SDK.DebuggerModel.Events.DebuggerWasEnabled, this._scheduleUpdateInDebugger, this);
     this._hasPendingUpdate = false;
     this._isUpdating = false;
     this._cancelCallback = false;
     this._currentState = null;
     if (this._debuggerModel.debuggerEnabled())
       this._scheduleUpdateInDebugger();
   }
 
   _resetLocations() {
     for (var uiLocation of this._uiLocations.values())
@@ skipping 49 matching lines @@
 
     var debuggerLocation = uiSourceCode ?
         this._debuggerWorkspaceBinding.uiLocationToRawLocation(this.target(), uiSourceCode, lineNumber, columnNumber) :
         null;
     var newState;
     if (this._breakpoint._isRemoved || !this._breakpoint.enabled() || this._scriptDiverged())
       newState = null;
     else if (debuggerLocation) {
       var script = debuggerLocation.script();
       if (script.sourceURL)
-        newState = new WebInspector.BreakpointManager.Breakpoint.State(
+        newState = new Bindings.BreakpointManager.Breakpoint.State(
             script.sourceURL, null, debuggerLocation.lineNumber, debuggerLocation.columnNumber, condition);
       else
-        newState = new WebInspector.BreakpointManager.Breakpoint.State(
+        newState = new Bindings.BreakpointManager.Breakpoint.State(
             null, debuggerLocation.scriptId, debuggerLocation.lineNumber, debuggerLocation.columnNumber, condition);
     } else if (this._breakpoint._currentState && this._breakpoint._currentState.url) {
       var position = this._breakpoint._currentState;
-      newState = new WebInspector.BreakpointManager.Breakpoint.State(
+      newState = new Bindings.BreakpointManager.Breakpoint.State(
           position.url, null, position.lineNumber, position.columnNumber, condition);
     } else if (uiSourceCode) {
-      newState = new WebInspector.BreakpointManager.Breakpoint.State(
+      newState = new Bindings.BreakpointManager.Breakpoint.State(
           uiSourceCode.url(), null, lineNumber, columnNumber, condition);
     }
-    if (this._debuggerId && WebInspector.BreakpointManager.Breakpoint.State.equals(newState, this._currentState)) {
+    if (this._debuggerId && Bindings.BreakpointManager.Breakpoint.State.equals(newState, this._currentState)) {
       callback();
       return;
     }
 
     this._breakpoint._currentState = newState;
 
     if (this._debuggerId) {
       this._resetLocations();
       this._debuggerModel.removeBreakpoint(this._debuggerId, this._didRemoveFromDebugger.bind(this, callback));
       this._scheduleUpdateInDebugger();
       this._currentState = null;
       return;
     }
 
     if (!newState) {
       callback();
       return;
     }
 
     var updateCallback = this._didSetBreakpointInDebugger.bind(this, callback);
     if (newState.url)
       this._debuggerModel.setBreakpointByURL(
           newState.url, newState.lineNumber, newState.columnNumber, this._breakpoint.condition(), updateCallback);
     else if (newState.scriptId)
       this._debuggerModel.setBreakpointBySourceId(
-          /** @type {!WebInspector.DebuggerModel.Location} */ (debuggerLocation), condition, updateCallback);
+          /** @type {!SDK.DebuggerModel.Location} */ (debuggerLocation), condition, updateCallback);
 
     this._currentState = newState;
   }
 
   /**
    * @param {function()} callback
    * @param {?Protocol.Debugger.BreakpointId} breakpointId
-   * @param {!Array.<!WebInspector.DebuggerModel.Location>} locations
+   * @param {!Array.<!SDK.DebuggerModel.Location>} locations
    */
   _didSetBreakpointInDebugger(callback, breakpointId, locations) {
     if (this._cancelCallback) {
       this._cancelCallback = false;
       callback();
       return;
     }
 
     if (!breakpointId) {
       this._breakpoint.remove(true);
@@ skipping 20 matching lines @@
       return;
     }
 
     this._resetLocations();
     this._debuggerModel.removeBreakpointListener(this._debuggerId, this._breakpointResolved, this);
     delete this._debuggerId;
     callback();
   }
 
   /**
-   * @param {!WebInspector.Event} event
+   * @param {!Common.Event} event
    */
   _breakpointResolved(event) {
-    this._addResolvedLocation(/** @type {!WebInspector.DebuggerModel.Location}*/ (event.data));
+    this._addResolvedLocation(/** @type {!SDK.DebuggerModel.Location}*/ (event.data));
   }
 
   /**
-   * @param {!WebInspector.DebuggerModel.Location} location
-   * @param {!WebInspector.LiveLocation} liveLocation
+   * @param {!SDK.DebuggerModel.Location} location
+   * @param {!Bindings.LiveLocation} liveLocation
    */
   _locationUpdated(location, liveLocation) {
     var uiLocation = liveLocation.uiLocation();
     if (!uiLocation)
       return;
     var oldUILocation = this._uiLocations.get(location.id()) || null;
     this._uiLocations.set(location.id(), uiLocation);
     this._breakpoint._replaceUILocation(oldUILocation, uiLocation);
   }
 
   /**
-   * @param {!WebInspector.DebuggerModel.Location} location
+   * @param {!SDK.DebuggerModel.Location} location
    * @return {boolean}
    */
   _addResolvedLocation(location) {
     var uiLocation = this._debuggerWorkspaceBinding.rawLocationToUILocation(location);
     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._debuggerWorkspaceBinding.createLiveLocation(
         location, this._locationUpdated.bind(this, location), this._liveLocations);
     return true;
   }
 
   _cleanUpAfterDebuggerIsGone() {
     if (this._isUpdating)
       this._cancelCallback = true;
 
     this._resetLocations();
     this._currentState = null;
     if (this._debuggerId)
       this._didRemoveFromDebugger(function() {});
   }
 
   _removeEventListeners() {
     this._debuggerModel.removeEventListener(
-        WebInspector.DebuggerModel.Events.DebuggerWasDisabled, this._cleanUpAfterDebuggerIsGone, this);
+        SDK.DebuggerModel.Events.DebuggerWasDisabled, this._cleanUpAfterDebuggerIsGone, this);
     this._debuggerModel.removeEventListener(
-        WebInspector.DebuggerModel.Events.DebuggerWasEnabled, this._scheduleUpdateInDebugger, this);
+        SDK.DebuggerModel.Events.DebuggerWasEnabled, this._scheduleUpdateInDebugger, this);
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.BreakpointManager.Breakpoint.State = class {
+Bindings.BreakpointManager.Breakpoint.State = class {
   /**
    * @param {?string} url
    * @param {?string} scriptId
    * @param {number} lineNumber
    * @param {number} columnNumber
    * @param {string} condition
    */
   constructor(url, scriptId, lineNumber, columnNumber, condition) {
     this.url = url;
     this.scriptId = scriptId;
     this.lineNumber = lineNumber;
     this.columnNumber = columnNumber;
     this.condition = condition;
   }
 
   /**
-   * @param {?WebInspector.BreakpointManager.Breakpoint.State|undefined} stateA
-   * @param {?WebInspector.BreakpointManager.Breakpoint.State|undefined} stateB
+   * @param {?Bindings.BreakpointManager.Breakpoint.State|undefined} stateA
+   * @param {?Bindings.BreakpointManager.Breakpoint.State|undefined} stateB
    * @return {boolean}
    */
   static equals(stateA, stateB) {
     if (!stateA || !stateB)
       return false;
 
     if (stateA.scriptId || stateB.scriptId)
       return false;
 
     return stateA.url === stateB.url && stateA.lineNumber === stateB.lineNumber &&
         stateA.columnNumber === stateB.columnNumber && stateA.condition === stateB.condition;
   }
 };
 
 
 /**
  * @unrestricted
  */
-WebInspector.BreakpointManager.Storage = class {
+Bindings.BreakpointManager.Storage = class {
   /**
-   * @param {!WebInspector.BreakpointManager} breakpointManager
-   * @param {?WebInspector.Setting} setting
+   * @param {!Bindings.BreakpointManager} breakpointManager
+   * @param {?Common.Setting} setting
    */
   constructor(breakpointManager, setting) {
     this._breakpointManager = breakpointManager;
-    this._setting = setting || WebInspector.settings.createLocalSetting('breakpoints', []);
+    this._setting = setting || Common.settings.createLocalSetting('breakpoints', []);
     var breakpoints = this._setting.get();
-    /** @type {!Object.<string, !WebInspector.BreakpointManager.Storage.Item>} */
+    /** @type {!Object.<string, !Bindings.BreakpointManager.Storage.Item>} */
     this._breakpoints = {};
     for (var i = 0; i < breakpoints.length; ++i) {
-      var breakpoint = /** @type {!WebInspector.BreakpointManager.Storage.Item} */ (breakpoints[i]);
+      var breakpoint = /** @type {!Bindings.BreakpointManager.Storage.Item} */ (breakpoints[i]);
       breakpoint.columnNumber = breakpoint.columnNumber || 0;
       this._breakpoints[breakpoint.sourceFileId + ':' + breakpoint.lineNumber + ':' + breakpoint.columnNumber] =
           breakpoint;
     }
   }
 
   mute() {
     this._muted = true;
   }
 
   unmute() {
     delete this._muted;
   }
 
   /**
    * @param {string} sourceFileId
-   * @return {!Array.<!WebInspector.BreakpointManager.Storage.Item>}
+   * @return {!Array.<!Bindings.BreakpointManager.Storage.Item>}
    */
   breakpointItems(sourceFileId) {
     var result = [];
     for (var id in this._breakpoints) {
       var breakpoint = this._breakpoints[id];
       if (breakpoint.sourceFileId === sourceFileId)
         result.push(breakpoint);
     }
     return result;
   }
 
   /**
-   * @param {!WebInspector.BreakpointManager.Breakpoint} breakpoint
+   * @param {!Bindings.BreakpointManager.Breakpoint} breakpoint
    */
   _updateBreakpoint(breakpoint) {
     if (this._muted || !breakpoint._breakpointStorageId())
       return;
-    this._breakpoints[breakpoint._breakpointStorageId()] = new WebInspector.BreakpointManager.Storage.Item(breakpoint);
+    this._breakpoints[breakpoint._breakpointStorageId()] = new Bindings.BreakpointManager.Storage.Item(breakpoint);
     this._save();
   }
 
   /**
-   * @param {!WebInspector.BreakpointManager.Breakpoint} breakpoint
+   * @param {!Bindings.BreakpointManager.Breakpoint} breakpoint
    */
   _removeBreakpoint(breakpoint) {
     if (this._muted)
       return;
     delete this._breakpoints[breakpoint._breakpointStorageId()];
     this._save();
   }
 
   _save() {
     var breakpointsArray = [];
     for (var id in this._breakpoints)
       breakpointsArray.push(this._breakpoints[id]);
     this._setting.set(breakpointsArray);
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.BreakpointManager.Storage.Item = class {
+Bindings.BreakpointManager.Storage.Item = class {
   /**
-   * @param {!WebInspector.BreakpointManager.Breakpoint} breakpoint
+   * @param {!Bindings.BreakpointManager.Breakpoint} breakpoint
    */
   constructor(breakpoint) {
     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;
+/** @type {!Bindings.BreakpointManager} */
+Bindings.breakpointManager;