DevTools: rename WebInspector into modules.

third_party/WebKit/LayoutTests/http/tests/inspector/debugger-test.js

 function scheduleTestFunction()
 {
     setTimeout(testFunction, 0);
 }
 
 var initialize_DebuggerTest = function() {
 
 InspectorTest.preloadPanel("sources");
 
 InspectorTest.startDebuggerTest = function(callback, quiet)
 {
     console.assert(InspectorTest.debuggerModel.debuggerEnabled(), "Debugger has to be enabled");
     if (quiet !== undefined)
         InspectorTest._quiet = quiet;
-    WebInspector.viewManager.showView("sources");
+    UI.viewManager.showView("sources");
 
-    InspectorTest.addSniffer(WebInspector.DebuggerModel.prototype, "_pausedScript", InspectorTest._pausedScript, true);
-    InspectorTest.addSniffer(WebInspector.DebuggerModel.prototype, "_resumedScript", InspectorTest._resumedScript, true);
+    InspectorTest.addSniffer(SDK.DebuggerModel.prototype, "_pausedScript", InspectorTest._pausedScript, true);
+    InspectorTest.addSniffer(SDK.DebuggerModel.prototype, "_resumedScript", InspectorTest._resumedScript, true);
     InspectorTest.safeWrap(callback)();
 };
 
 InspectorTest.startDebuggerTestPromise = function(quiet)
 {
     var cb;
     var p = new Promise(fullfill => cb = fullfill);
     InspectorTest.startDebuggerTest(cb, quiet);
     return p;
 }
 
 InspectorTest.completeDebuggerTest = function()
 {
-    WebInspector.breakpointManager.setBreakpointsActive(true);
+    Bindings.breakpointManager.setBreakpointsActive(true);
     InspectorTest.resumeExecution(InspectorTest.completeTest.bind(InspectorTest));
 };
 
 (function() {
     // FIXME: Until there is no window.onerror() for uncaught exceptions in promises
     // we use this hack to print the exceptions instead of just timing out.
 
     var origThen = Promise.prototype.then;
     var origCatch = Promise.prototype.catch;
 
@@ skipping 116 matching lines @@
     callback = InspectorTest.safeWrap(callback);
 
     if (!InspectorTest._pausedScriptArguments)
         callback();
     else
         InspectorTest._waitUntilResumedCallback = callback;
 };
 
 InspectorTest.resumeExecution = function(callback)
 {
-    if (WebInspector.panels.sources.paused())
-        WebInspector.panels.sources._togglePause();
+    if (UI.panels.sources.paused())
+        UI.panels.sources._togglePause();
     InspectorTest.waitUntilResumed(callback);
 };
 
 InspectorTest.waitUntilPausedAndDumpStackAndResume = function(callback, options)
 {
     InspectorTest.waitUntilPaused(paused);
-    InspectorTest.addSniffer(WebInspector.SourcesPanel.prototype, "_updateDebuggerButtonsAndStatus", setStatus);
+    InspectorTest.addSniffer(Sources.SourcesPanel.prototype, "_updateDebuggerButtonsAndStatus", setStatus);
 
     var caption;
     var callFrames;
     var asyncStackTrace;
 
     function setStatus()
     {
         var statusElement = this.element.querySelector(".paused-message");
         caption = statusElement.deepTextContent();
         if (callFrames)
@@ skipping 16 matching lines @@
     }
 
     function step2()
     {
         InspectorTest.resumeExecution(InspectorTest.safeWrap(callback));
     }
 };
 
 InspectorTest.stepOver = function()
 {
-    Promise.resolve().then(function(){WebInspector.panels.sources._stepOver()});
+    Promise.resolve().then(function(){UI.panels.sources._stepOver()});
 };
 
 InspectorTest.stepInto = function()
 {
-    Promise.resolve().then(function(){WebInspector.panels.sources._stepInto()});
+    Promise.resolve().then(function(){UI.panels.sources._stepInto()});
 };
 
 InspectorTest.stepOut = function()
 {
-    Promise.resolve().then(function(){WebInspector.panels.sources._stepOut()});
+    Promise.resolve().then(function(){UI.panels.sources._stepOut()});
 };
 
 InspectorTest.togglePause = function()
 {
-    Promise.resolve().then(function(){WebInspector.panels.sources._togglePause()});
+    Promise.resolve().then(function(){UI.panels.sources._togglePause()});
 };
 
 InspectorTest.waitUntilPausedAndPerformSteppingActions = function(actions, callback)
 {
     callback = InspectorTest.safeWrap(callback);
     InspectorTest.waitUntilPaused(didPause);
 
     function didPause(callFrames, reason, breakpointIds, asyncStackTrace)
     {
         var action = actions.shift();
@@ skipping 43 matching lines @@
 {
     var results = [];
     options = options || {};
     function printCallFrames(callFrames, locationFunction, returnValueFunction)
     {
         var printed = 0;
         for (var i = 0; i < callFrames.length; i++) {
             var frame = callFrames[i];
             var location = locationFunction.call(frame);
             var script = location.script();
-            var uiLocation = WebInspector.debuggerWorkspaceBinding.rawLocationToUILocation(location);
-            var isFramework = WebInspector.blackboxManager.isBlackboxedRawLocation(location);
+            var uiLocation = Bindings.debuggerWorkspaceBinding.rawLocationToUILocation(location);
+            var isFramework = Bindings.blackboxManager.isBlackboxedRawLocation(location);
             if (options.dropFrameworkCallFrames && isFramework)
                 continue;
             var url;
             var lineNumber;
-            if (uiLocation && uiLocation.uiSourceCode.project().type() !== WebInspector.projectTypes.Debugger) {
+            if (uiLocation && uiLocation.uiSourceCode.project().type() !== Workspace.projectTypes.Debugger) {
                 url = uiLocation.uiSourceCode.name();
                 lineNumber = uiLocation.lineNumber + 1;
             } else {
-                url = WebInspector.displayNameForURL(script.sourceURL);
+                url = Bindings.displayNameForURL(script.sourceURL);
                 lineNumber = location.lineNumber + 1;
             }
             var s = (isFramework ? "  * " : "    ") + (printed++) + ") " + frame.functionName + " (" + url + (options.dropLineNumbers ? "" : ":" + lineNumber) + ")";
             results.push(s);
             if (options.printReturnValue && returnValueFunction && returnValueFunction.call(frame))
                 results.push("       <return>: " + returnValueFunction.call(frame).description);
             if (frame.functionName === "scheduleTestFunction") {
                 var remainingFrames = callFrames.length - 1 - i;
                 if (remainingFrames)
                     results.push("    <... skipped remaining frames ...>");
                 break;
             }
         }
         return printed;
     }
 
     function runtimeCallFramePosition()
     {
-        return new WebInspector.DebuggerModel.Location(debuggerModel, this.scriptId, this.lineNumber, this.columnNumber);
+        return new SDK.DebuggerModel.Location(debuggerModel, this.scriptId, this.lineNumber, this.columnNumber);
     }
 
     results.push("Call stack:");
-    printCallFrames(callFrames, WebInspector.DebuggerModel.CallFrame.prototype.location, WebInspector.DebuggerModel.CallFrame.prototype.returnValue);
+    printCallFrames(callFrames, SDK.DebuggerModel.CallFrame.prototype.location, SDK.DebuggerModel.CallFrame.prototype.returnValue);
     while (asyncStackTrace) {
         results.push("    [" + (asyncStackTrace.description || "Async Call") + "]");
-        var debuggerModel = WebInspector.DebuggerModel.fromTarget(WebInspector.targetManager.mainTarget());
+        var debuggerModel = SDK.DebuggerModel.fromTarget(SDK.targetManager.mainTarget());
         var printed = printCallFrames(asyncStackTrace.callFrames, runtimeCallFramePosition);
         if (!printed)
             results.pop();
         asyncStackTrace = asyncStackTrace.parent;
     }
     return results.join("\n");
 };
 
 InspectorTest.dumpSourceFrameContents = function(sourceFrame)
 {
     InspectorTest.addResult("==Source frame contents start==");
     var textEditor = sourceFrame._textEditor;
     for (var i = 0; i < textEditor.linesCount; ++i)
         InspectorTest.addResult(textEditor.line(i));
     InspectorTest.addResult("==Source frame contents end==");
 };
 
 InspectorTest._pausedScript = function(callFrames, reason, auxData, breakpointIds, asyncStackTrace)
 {
     if (!InspectorTest._quiet)
         InspectorTest.addResult("Script execution paused.");
-    var debuggerModel = WebInspector.DebuggerModel.fromTarget(this.target());
-    InspectorTest._pausedScriptArguments = [WebInspector.DebuggerModel.CallFrame.fromPayloadArray(debuggerModel, callFrames), reason, breakpointIds, asyncStackTrace, auxData];
+    var debuggerModel = SDK.DebuggerModel.fromTarget(this.target());
+    InspectorTest._pausedScriptArguments = [SDK.DebuggerModel.CallFrame.fromPayloadArray(debuggerModel, callFrames), reason, breakpointIds, asyncStackTrace, auxData];
     if (InspectorTest._waitUntilPausedCallback) {
         var callback = InspectorTest._waitUntilPausedCallback;
         delete InspectorTest._waitUntilPausedCallback;
         setTimeout(() => callback.apply(callback, InspectorTest._pausedScriptArguments));
     }
 };
 
 InspectorTest._resumedScript = function()
 {
     if (!InspectorTest._quiet)
         InspectorTest.addResult("Script execution resumed.");
     delete InspectorTest._pausedScriptArguments;
     if (InspectorTest._waitUntilResumedCallback) {
         var callback = InspectorTest._waitUntilResumedCallback;
         delete InspectorTest._waitUntilResumedCallback;
         callback();
     }
 };
 
 InspectorTest.showUISourceCode = function(uiSourceCode, callback)
 {
-    var panel = WebInspector.panels.sources;
+    var panel = UI.panels.sources;
     panel.showUISourceCode(uiSourceCode);
     var sourceFrame = panel.visibleView;
     if (sourceFrame.loaded)
         callback(sourceFrame);
     else
         InspectorTest.addSniffer(sourceFrame, "onTextEditorContentSet", callback && callback.bind(null, sourceFrame));
 };
 
 InspectorTest.showUISourceCodePromise = function(uiSourceCode)
 {
     var fulfill;
     var promise = new Promise(x => fulfill = x);
     InspectorTest.showUISourceCode(uiSourceCode, fulfill);
     return promise;
 }
 
 InspectorTest.showScriptSource = function(scriptName, callback)
 {
     InspectorTest.waitForScriptSource(scriptName, onScriptSource);
 
     function onScriptSource(uiSourceCode)
     {
         InspectorTest.showUISourceCode(uiSourceCode, callback);
     }
 };
 
 InspectorTest.waitForScriptSource = function(scriptName, callback)
 {
-    var panel = WebInspector.panels.sources;
+    var panel = UI.panels.sources;
     var uiSourceCodes = panel._workspace.uiSourceCodes();
     for (var i = 0; i < uiSourceCodes.length; ++i) {
-        if (uiSourceCodes[i].project().type() === WebInspector.projectTypes.Service)
+        if (uiSourceCodes[i].project().type() === Workspace.projectTypes.Service)
             continue;
         if (uiSourceCodes[i].name() === scriptName) {
             callback(uiSourceCodes[i]);
             return;
         }
     }
 
-    InspectorTest.addSniffer(WebInspector.SourcesView.prototype, "_addUISourceCode", InspectorTest.waitForScriptSource.bind(InspectorTest, scriptName, callback));
+    InspectorTest.addSniffer(Sources.SourcesView.prototype, "_addUISourceCode", InspectorTest.waitForScriptSource.bind(InspectorTest, scriptName, callback));
 };
 
 InspectorTest.setBreakpoint = function(sourceFrame, lineNumber, condition, enabled)
 {
     if (!sourceFrame._muted)
         sourceFrame._setBreakpoint(lineNumber, 0, condition, enabled);
 };
 
 InspectorTest.removeBreakpoint = function(sourceFrame, lineNumber)
 {
     sourceFrame._breakpointManager.findBreakpoints(sourceFrame._uiSourceCode, lineNumber)[0].remove();
 };
 
 InspectorTest.dumpBreakpointSidebarPane = function(title)
 {
-    var paneElement = self.runtime.sharedInstance(WebInspector.JavaScriptBreakpointsSidebarPane).element;
+    var paneElement = self.runtime.sharedInstance(Sources.JavaScriptBreakpointsSidebarPane).element;
     InspectorTest.addResult("Breakpoint sidebar pane " + (title || ""));
     InspectorTest.addResult(InspectorTest.textContentWithLineBreaks(paneElement));
 };
 
 InspectorTest.dumpScopeVariablesSidebarPane = function()
 {
     InspectorTest.addResult("Scope variables sidebar pane:");
     var sections = InspectorTest.scopeChainSections();
     for (var i = 0; i < sections.length; ++i) {
         var textContent = InspectorTest.textContentWithLineBreaks(sections[i].element);
         var text = InspectorTest.clearSpecificInfoFromStackFrames(textContent);
         if (text.length > 0)
             InspectorTest.addResult(text);
         if (!sections[i].objectTreeElement().expanded)
             InspectorTest.addResult("    <section collapsed>");
     }
 };
 
 InspectorTest.scopeChainSections = function()
 {
-    var children = self.runtime.sharedInstance(WebInspector.ScopeChainSidebarPane).contentElement.children;
+    var children = self.runtime.sharedInstance(Sources.ScopeChainSidebarPane).contentElement.children;
     var sections = [];
     for (var i = 0; i < children.length; ++i)
         sections.push(children[i]._section);
 
     return sections;
 }
 
 InspectorTest.expandScopeVariablesSidebarPane = function(callback)
 {
     // Expand all but the global scope. Expanding global scope takes for too long so we keep it collapsed.
@@ skipping 59 matching lines @@
     for (var scriptId in InspectorTest.debuggerModel._scripts) {
         var script = InspectorTest.debuggerModel._scripts[scriptId];
         if (!filter || filter(script))
             scripts.push(script);
     }
     return scripts;
 };
 
 InspectorTest.createScriptMock = function(url, startLine, startColumn, isContentScript, source, target, preRegisterCallback)
 {
-    target = target || WebInspector.targetManager.mainTarget();
-    var debuggerModel = WebInspector.DebuggerModel.fromTarget(target);
+    target = target || SDK.targetManager.mainTarget();
+    var debuggerModel = SDK.DebuggerModel.fromTarget(target);
     var scriptId = ++InspectorTest._lastScriptId + "";
     var lineCount = source.computeLineEndings().length;
     var endLine = startLine + lineCount - 1;
     var endColumn = lineCount === 1 ? startColumn + source.length : source.length - source.computeLineEndings()[lineCount - 2];
     var hasSourceURL = !!source.match(/\/\/#\ssourceURL=\s*(\S*?)\s*$/m) || !!source.match(/\/\/@\ssourceURL=\s*(\S*?)\s*$/m);
-    var script = new WebInspector.Script(debuggerModel, scriptId, url, startLine, startColumn, endLine, endColumn, 0, "", isContentScript, false, undefined, hasSourceURL);
+    var script = new SDK.Script(debuggerModel, scriptId, url, startLine, startColumn, endLine, endColumn, 0, "", isContentScript, false, undefined, hasSourceURL);
     script.requestContent = function()
     {
-        var trimmedSource = WebInspector.Script._trimSourceURLComment(source);
+        var trimmedSource = SDK.Script._trimSourceURLComment(source);
         return Promise.resolve(trimmedSource);
     };
     if (preRegisterCallback)
         preRegisterCallback(script);
     debuggerModel._registerScript(script);
     return script;
 };
 
 InspectorTest._lastScriptId = 0;
 
 InspectorTest.checkRawLocation = function(script, lineNumber, columnNumber, location)
 {
     InspectorTest.assertEquals(script.scriptId, location.scriptId, "Incorrect scriptId");
     InspectorTest.assertEquals(lineNumber, location.lineNumber, "Incorrect lineNumber");
     InspectorTest.assertEquals(columnNumber, location.columnNumber, "Incorrect columnNumber");
 };
 
 InspectorTest.checkUILocation = function(uiSourceCode, lineNumber, columnNumber, location)
 {
     InspectorTest.assertEquals(uiSourceCode, location.uiSourceCode, "Incorrect uiSourceCode, expected '" + (uiSourceCode ? uiSourceCode.url() : null) + "'," +
                                                                     " but got '" + (location.uiSourceCode ? location.uiSourceCode.url() : null) + "'");
     InspectorTest.assertEquals(lineNumber, location.lineNumber, "Incorrect lineNumber, expected '" + lineNumber + "', but got '" + location.lineNumber + "'");
     InspectorTest.assertEquals(columnNumber, location.columnNumber, "Incorrect columnNumber, expected '" + columnNumber + "', but got '" + location.columnNumber + "'");
 };
 
 InspectorTest.scriptFormatter = function()
 {
-    return self.runtime.allInstances(WebInspector.SourcesView.EditorAction).then(function(editorActions) {
+    return self.runtime.allInstances(Sources.SourcesView.EditorAction).then(function(editorActions) {
         for (var i = 0; i < editorActions.length; ++i) {
-            if (editorActions[i] instanceof WebInspector.ScriptFormatterEditorAction)
+            if (editorActions[i] instanceof Sources.ScriptFormatterEditorAction)
                 return editorActions[i];
         }
         return null;
     });
 };
 
 InspectorTest.waitForExecutionContextInTarget = function(target, callback)
 {
     if (target.runtimeModel.executionContexts().length) {
         callback(target.runtimeModel.executionContexts()[0]);
         return;
     }
-    target.runtimeModel.addEventListener(WebInspector.RuntimeModel.Events.ExecutionContextCreated, contextCreated);
+    target.runtimeModel.addEventListener(SDK.RuntimeModel.Events.ExecutionContextCreated, contextCreated);
 
     function contextCreated()
     {
-        target.runtimeModel.removeEventListener(WebInspector.RuntimeModel.Events.ExecutionContextCreated, contextCreated);
+        target.runtimeModel.removeEventListener(SDK.RuntimeModel.Events.ExecutionContextCreated, contextCreated);
         callback(target.runtimeModel.executionContexts()[0]);
     }
 }
 
 InspectorTest.selectThread = function(target)
 {
-    var threadsPane = self.runtime.sharedInstance(WebInspector.ThreadsSidebarPane);
+    var threadsPane = self.runtime.sharedInstance(Sources.ThreadsSidebarPane);
     var listItem = threadsPane._listItemForTarget(target);
     threadsPane._onListItemClick(listItem);
 }
 
 InspectorTest.evaluateOnCurrentCallFrame = function(code)
 {
     return new Promise(succ => InspectorTest.debuggerModel.evaluateOnSelectedCallFrame(code, "console", false, true, false, false, InspectorTest.safeWrap(succ)));
 }
 
 };