DevTools: rename WebInspector into modules.

third_party/WebKit/LayoutTests/inspector/sources/debugger-breakpoints/breakpoint-manager.js

 var initialize_BreakpointManagerTest = function() {
 
 InspectorTest.uiSourceCodes = {};
 
 InspectorTest.dumpTargetIds = false;
 
 InspectorTest.initializeDefaultMappingOnTarget = function(target)
 {
     var defaultMapping = {
         rawLocationToUILocation: function(rawLocation)
         {
             return InspectorTest.uiSourceCodes[rawLocation.scriptId].uiLocation(rawLocation.lineNumber, 0);
         },
 
         uiLocationToRawLocation: function(uiSourceCode, lineNumber)
         {
             if (!InspectorTest.uiSourceCodes[uiSourceCode.url()])
                 return null;
-            return new WebInspector.DebuggerModel.Location(target.debuggerModel, uiSourceCode.url(), lineNumber, 0);
+            return new SDK.DebuggerModel.Location(target.debuggerModel, uiSourceCode.url(), lineNumber, 0);
         },
 
         isIdentity: function()
         {
             return true;
         }
     };
     target.defaultMapping = defaultMapping;
 }
 
 InspectorTest.dumpTarget = function(targetAware)
 {
     return InspectorTest.dumpTargetIds ?  "target " + targetAware.target().id() + " " : "";
 }
 
-InspectorTest.DebuggerModelMock = class extends WebInspector.SDKModel {
+InspectorTest.DebuggerModelMock = class extends SDK.SDKModel {
     constructor(target)
     {
-        super(WebInspector.DebuggerModel, target);
-        this._breakpointResolvedEventTarget = new WebInspector.Object();
+        super(SDK.DebuggerModel, target);
+        this._breakpointResolvedEventTarget = new Common.Object();
         this._scripts = {};
         this._breakpoints = {};
         this._debuggerWorkspaceBinding = InspectorTest.testDebuggerWorkspaceBinding;
     }
 
     target()
     {
         return this._target;
     }
 
     _targetDisposed() { }
 
     debuggerEnabled()
     {
         return true;
     }
 
     scriptsForSourceURL(url)
     {
         var script = this._scriptForURL(url);
         return script ? [script] : [];
     }
 
     _addScript(scriptId, url)
     {
-        var script = new WebInspector.Script(this, scriptId, url);
+        var script = new SDK.Script(this, scriptId, url);
         this._scripts[scriptId] = script;
         this._debuggerWorkspaceBinding._targetToData.get(this._target)._parsedScriptSource({data: script});
     }
 
     _registerScript(script)
     {
         this._scripts[script.scriptId] = script;
         this._debuggerWorkspaceBinding._targetToData.get(this._target)._parsedScriptSource({data: script});
     }
 
@@ skipping 17 matching lines @@
             if (window.setBreakpointCallback) {
                 var savedCallback = window.setBreakpointCallback;
                 delete window.setBreakpointCallback;
                 savedCallback();
             }
         }
     }
 
     createRawLocation(script, line, column)
     {
-        return new WebInspector.DebuggerModel.Location(this, script.scriptId, line, column);
+        return new SDK.DebuggerModel.Location(this, script.scriptId, line, column);
     }
 
     setBreakpointByURL(url, lineNumber, columnNumber, condition, callback)
     {
         InspectorTest.addResult("    " + InspectorTest.dumpTarget(this) + "debuggerModel.setBreakpoint(" + [url, lineNumber, condition].join(":") + ")");
 
         var breakpointId = url + ":" + lineNumber;
         if (this._breakpoints[breakpointId]) {
             this._scheduleSetBeakpointCallback(callback, null);
             return;
         }
         this._breakpoints[breakpointId] = true;
 
         if (lineNumber >= 2000) {
             this._scheduleSetBeakpointCallback(callback, breakpointId, []);
             return;
         }
         if (lineNumber >= 1000) {
-            var shiftedLocation = new WebInspector.DebuggerModel.Location(this, url, lineNumber + 10, columnNumber);
+            var shiftedLocation = new SDK.DebuggerModel.Location(this, url, lineNumber + 10, columnNumber);
             this._scheduleSetBeakpointCallback(callback, breakpointId, [shiftedLocation]);
             return;
         }
 
         var locations = [];
         var script = this._scriptForURL(url);
         if (script) {
-            var location = new WebInspector.DebuggerModel.Location(this, script.scriptId, lineNumber, 0);
+            var location = new SDK.DebuggerModel.Location(this, script.scriptId, lineNumber, 0);
             locations.push(location);
         }
 
         this._scheduleSetBeakpointCallback(callback, breakpointId, locations);
     }
 
     removeBreakpoint(breakpointId, callback)
     {
         InspectorTest.addResult("    " + InspectorTest.dumpTarget(this) + "debuggerModel.removeBreakpoint(" + breakpointId + ")");
         delete this._breakpoints[breakpointId];
@@ skipping 39 matching lines @@
     }
 
     _breakpointResolved(breakpointId, location)
     {
         this._breakpointResolvedEventTarget.dispatchEventToListeners(breakpointId, location);
     }
 };
 
 InspectorTest.setupLiveLocationSniffers = function()
 {
-    InspectorTest.addSniffer(WebInspector.DebuggerWorkspaceBinding.prototype, "createLiveLocation", function(rawLocation)
+    InspectorTest.addSniffer(Bindings.DebuggerWorkspaceBinding.prototype, "createLiveLocation", function(rawLocation)
     {
         InspectorTest.addResult("    Location created: " + InspectorTest.dumpTarget(rawLocation) + rawLocation.scriptId + ":" + rawLocation.lineNumber);
     }, true);
-    InspectorTest.addSniffer(WebInspector.DebuggerWorkspaceBinding.Location.prototype, "dispose", function()
+    InspectorTest.addSniffer(Bindings.DebuggerWorkspaceBinding.Location.prototype, "dispose", function()
     {
         InspectorTest.addResult("    Location disposed: " + InspectorTest.dumpTarget(this._rawLocation) + this._rawLocation.scriptId + ":" + this._rawLocation.lineNumber);
     }, true);
 }
 
 InspectorTest.addScript = function(target, breakpointManager, url)
 {
     target.debuggerModel._addScript(url, url);
     InspectorTest.addResult("  Adding script: " + url);
-    var uiSourceCodes = breakpointManager._workspace.uiSourceCodesForProjectType(WebInspector.projectTypes.Debugger);
+    var uiSourceCodes = breakpointManager._workspace.uiSourceCodesForProjectType(Workspace.projectTypes.Debugger);
     for (var i = 0; i < uiSourceCodes.length; ++i) {
         var uiSourceCode = uiSourceCodes[i];
         if (uiSourceCode.url() === url) {
             breakpointManager._debuggerWorkspaceBinding.setSourceMapping(target, uiSourceCode, breakpointManager.defaultMapping);
             InspectorTest.uiSourceCodes[url] = uiSourceCode;
             return uiSourceCode;
         }
     }
 }
 
 InspectorTest.addUISourceCode = function(target, breakpointManager, url, doNotSetSourceMapping, doNotAddScript)
 {
     if (!doNotAddScript)
         InspectorTest.addScript(target, breakpointManager, url);
     InspectorTest.addResult("  Adding UISourceCode: " + url);
-    var contentProvider = WebInspector.StaticContentProvider.fromString(url, WebInspector.resourceTypes.Script, "");
+    var contentProvider = Common.StaticContentProvider.fromString(url, Common.resourceTypes.Script, "");
     var binding = breakpointManager._debuggerWorkspaceBinding;
     var uiSourceCode = InspectorTest.testNetworkProject.addFile(contentProvider, null);
     InspectorTest.uiSourceCodes[url] = uiSourceCode;
     if (!doNotSetSourceMapping) {
         breakpointManager._debuggerWorkspaceBinding.setSourceMapping(target, uiSourceCode, breakpointManager.defaultMapping);
         breakpointManager._debuggerWorkspaceBinding.updateLocations(target.debuggerModel.scriptForId(url));
     }
     return uiSourceCode;
 }
 
 InspectorTest.createBreakpointManager = function(targetManager, debuggerWorkspaceBinding, persistentBreakpoints)
 {
     InspectorTest._pendingBreakpointUpdates = 0;
-    InspectorTest.addSniffer(WebInspector.BreakpointManager.TargetBreakpoint.prototype, "_updateInDebugger", updateInDebugger, true);
-    InspectorTest.addSniffer(WebInspector.BreakpointManager.TargetBreakpoint.prototype, "_didUpdateInDebugger", didUpdateInDebugger, true);
+    InspectorTest.addSniffer(Bindings.BreakpointManager.TargetBreakpoint.prototype, "_updateInDebugger", updateInDebugger, true);
+    InspectorTest.addSniffer(Bindings.BreakpointManager.TargetBreakpoint.prototype, "_didUpdateInDebugger", didUpdateInDebugger, true);
 
     function updateInDebugger()
     {
         InspectorTest._pendingBreakpointUpdates++;
     }
 
     function didUpdateInDebugger()
     {
         InspectorTest._pendingBreakpointUpdates--;
         InspectorTest._notifyAfterBreakpointUpdate();
@@ skipping 18 matching lines @@
         InspectorTest.addResult("    breakpointRemoved(" + [uiLocation.uiSourceCode.url(), uiLocation.lineNumber, uiLocation.columnNumber].join(", ") + ")");
     }
     var targets = targetManager.targets();
     var mappingForManager;
     for (var i = 0; i < targets.length; ++i) {
         InspectorTest.initializeDefaultMappingOnTarget(targets[i]);
         if (!mappingForManager)
             mappingForManager = targets[i].defaultMapping;
     }
 
-    var breakpointManager = new WebInspector.BreakpointManager(setting, debuggerWorkspaceBinding._workspace, targetManager, debuggerWorkspaceBinding);
+    var breakpointManager = new Bindings.BreakpointManager(setting, debuggerWorkspaceBinding._workspace, targetManager, debuggerWorkspaceBinding);
     breakpointManager.defaultMapping = mappingForManager;
-    breakpointManager.addEventListener(WebInspector.BreakpointManager.Events.BreakpointAdded, breakpointAdded);
-    breakpointManager.addEventListener(WebInspector.BreakpointManager.Events.BreakpointRemoved, breakpointRemoved);
+    breakpointManager.addEventListener(Bindings.BreakpointManager.Events.BreakpointAdded, breakpointAdded);
+    breakpointManager.addEventListener(Bindings.BreakpointManager.Events.BreakpointRemoved, breakpointRemoved);
     InspectorTest.addResult("  Created breakpoints manager");
     InspectorTest.dumpBreakpointStorage(breakpointManager);
     return breakpointManager;
 }
 
 InspectorTest.setBreakpoint = function(breakpointManager, uiSourceCode, lineNumber, columnNumber, condition, enabled, setBreakpointCallback)
 {
     InspectorTest.addResult("  Setting breakpoint at " + uiSourceCode.url() + ":" + lineNumber + ":" + columnNumber + " enabled:" + enabled + " condition:" + condition);
     if (setBreakpointCallback)
         window.setBreakpointCallback = setBreakpointCallback;
@@ skipping 91 matching lines @@
     }
 
     function finish()
     {
         InspectorTest.dumpBreakpointLocations(breakpointManager);
         next();
     }
 }
 
 }