DevTools: rename WebInspector into modules.

third_party/WebKit/Source/devtools/front_end/Tests.js

 /*
  * Copyright (C) 2010 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 181 matching lines @@
         override.apply(this, arguments);
       } catch (e) {
         test.fail('Exception in overriden method \'' + methodName + '\': ' + e);
       }
       return result;
     };
   };
 
   /**
    * Waits for current throttler invocations, if any.
-   * @param {!WebInspector.Throttler} throttler
+   * @param {!Common.Throttler} throttler
    * @param {function()} callback
    */
   TestSuite.prototype.waitForThrottler = function(throttler, callback) {
     var test = this;
     var scheduleShouldFail = true;
     test.addSniffer(throttler, 'schedule', onSchedule);
 
     function hasSomethingScheduled() {
       return throttler._isRunningProcess || throttler._process;
     }
@@ skipping 13 matching lines @@
         test.fail('Unexpected Throttler.schedule');
     }
 
     checkState();
   };
 
   /**
    * @param {string} panelName Name of the panel to show.
    */
   TestSuite.prototype.showPanel = function(panelName) {
-    return WebInspector.inspectorView.showPanel(panelName);
+    return UI.inspectorView.showPanel(panelName);
   };
 
   // UI Tests
 
   /**
    * Tests that scripts tab can be open and populated with inspected scripts.
    */
   TestSuite.prototype.testShowScriptsTab = function() {
     var test = this;
     this.showPanel('sources').then(function() {
       // There should be at least main page script.
       this._waitUntilScriptsAreParsed(['debugger_test_page.html'], function() {
         test.releaseControl();
       });
     }.bind(this));
     // Wait until all scripts are added to the debugger.
     this.takeControl();
   };
 
   /**
    * Tests that scripts tab is populated with inspected scripts even if it
    * hadn't been shown by the moment inspected paged refreshed.
    * @see http://crbug.com/26312
    */
   TestSuite.prototype.testScriptsTabIsPopulatedOnInspectedPageRefresh = function() {
     var test = this;
-    var debuggerModel = WebInspector.DebuggerModel.fromTarget(WebInspector.targetManager.mainTarget());
-    debuggerModel.addEventListener(WebInspector.DebuggerModel.Events.GlobalObjectCleared, waitUntilScriptIsParsed);
+    var debuggerModel = SDK.DebuggerModel.fromTarget(SDK.targetManager.mainTarget());
+    debuggerModel.addEventListener(SDK.DebuggerModel.Events.GlobalObjectCleared, waitUntilScriptIsParsed);
 
     this.showPanel('elements').then(function() {
       // Reload inspected page. It will reset the debugger agent.
       test.evaluateInConsole_('window.location.reload(true);', function(resultText) {});
     });
 
     function waitUntilScriptIsParsed() {
-      debuggerModel.removeEventListener(WebInspector.DebuggerModel.Events.GlobalObjectCleared, waitUntilScriptIsParsed);
+      debuggerModel.removeEventListener(SDK.DebuggerModel.Events.GlobalObjectCleared, waitUntilScriptIsParsed);
       test.showPanel('sources').then(function() {
         test._waitUntilScriptsAreParsed(['debugger_test_page.html'], function() {
           test.releaseControl();
         });
       });
     }
 
     // Wait until all scripts are added to the debugger.
     this.takeControl();
   };
@@ skipping 60 matching lines @@
       });
     });
 
     // Wait until all scripts are added to the debugger.
     this.takeControl();
   };
 
   // Tests that debugger works correctly if pause event occurs when DevTools
   // frontend is being loaded.
   TestSuite.prototype.testPauseWhenLoadingDevTools = function() {
-    var debuggerModel = WebInspector.DebuggerModel.fromTarget(WebInspector.targetManager.mainTarget());
+    var debuggerModel = SDK.DebuggerModel.fromTarget(SDK.targetManager.mainTarget());
     if (debuggerModel.debuggerPausedDetails)
       return;
 
     this.showPanel('sources').then(function() {
       // Script execution can already be paused.
 
       this._waitForScriptPause(this.releaseControl.bind(this));
     }.bind(this));
 
     this.takeControl();
   };
 
   // Tests that pressing "Pause" will pause script execution if the script
   // is already running.
   TestSuite.prototype.testPauseWhenScriptIsRunning = function() {
     this.showPanel('sources').then(function() {
       this.evaluateInConsole_('setTimeout("handleClick()", 0)', didEvaluateInConsole.bind(this));
     }.bind(this));
 
     function didEvaluateInConsole(resultText) {
       this.assertTrue(!isNaN(resultText), 'Failed to get timer id: ' + resultText);
       // Wait for some time to make sure that inspected page is running the
       // infinite loop.
       setTimeout(testScriptPause.bind(this), 300);
     }
 
     function testScriptPause() {
       // The script should be in infinite loop. Click "Pause" button to
       // pause it and wait for the result.
-      WebInspector.panels.sources._togglePause();
+      UI.panels.sources._togglePause();
 
       this._waitForScriptPause(this.releaseControl.bind(this));
     }
 
     this.takeControl();
   };
 
   /**
    * Tests network size.
    */
   TestSuite.prototype.testNetworkSize = function() {
     var test = this;
 
     function finishResource(resource, finishTime) {
       test.assertEquals(25, resource.resourceSize, 'Incorrect total data length');
       test.releaseControl();
     }
 
-    this.addSniffer(WebInspector.NetworkDispatcher.prototype, '_finishNetworkRequest', finishResource);
+    this.addSniffer(SDK.NetworkDispatcher.prototype, '_finishNetworkRequest', finishResource);
 
     // Reload inspected page to sniff network events
     test.evaluateInConsole_('window.location.reload(true);', function(resultText) {});
 
     this.takeControl();
   };
 
   /**
    * Tests network sync size.
    */
   TestSuite.prototype.testNetworkSyncSize = function() {
     var test = this;
 
     function finishResource(resource, finishTime) {
       test.assertEquals(25, resource.resourceSize, 'Incorrect total data length');
       test.releaseControl();
     }
 
-    this.addSniffer(WebInspector.NetworkDispatcher.prototype, '_finishNetworkRequest', finishResource);
+    this.addSniffer(SDK.NetworkDispatcher.prototype, '_finishNetworkRequest', finishResource);
 
     // Send synchronous XHR to sniff network events
     test.evaluateInConsole_(
         'var xhr = new XMLHttpRequest(); xhr.open("GET", "chunked", false); xhr.send(null);', function() {});
 
     this.takeControl();
   };
 
   /**
    * Tests network raw headers text.
    */
   TestSuite.prototype.testNetworkRawHeadersText = function() {
     var test = this;
 
     function finishResource(resource, finishTime) {
       if (!resource.responseHeadersText)
         test.fail('Failure: resource does not have response headers text');
       var index = resource.responseHeadersText.indexOf('Date:');
       test.assertEquals(
           112, resource.responseHeadersText.substring(index).length, 'Incorrect response headers text length');
       test.releaseControl();
     }
 
-    this.addSniffer(WebInspector.NetworkDispatcher.prototype, '_finishNetworkRequest', finishResource);
+    this.addSniffer(SDK.NetworkDispatcher.prototype, '_finishNetworkRequest', finishResource);
 
     // Reload inspected page to sniff network events
     test.evaluateInConsole_('window.location.reload(true);', function(resultText) {});
 
     this.takeControl();
   };
 
   /**
    * Tests network timing.
    */
@@ skipping 14 matching lines @@
           'Time between responseReceivedTime and startTime should be >=0.07s, but was ' +
               'responseReceivedTime=' + resource.responseReceivedTime + ', startTime=' + resource.startTime + '.');
       test.assertTrue(
           resource.endTime - resource.startTime >= 0.14,
           'Time between endTime and startTime should be >=0.14s, but was ' +
               'endtime=' + resource.endTime + ', startTime=' + resource.startTime + '.');
 
       test.releaseControl();
     }
 
-    this.addSniffer(WebInspector.NetworkDispatcher.prototype, '_finishNetworkRequest', finishResource);
+    this.addSniffer(SDK.NetworkDispatcher.prototype, '_finishNetworkRequest', finishResource);
 
     // Reload inspected page to sniff network events
     test.evaluateInConsole_('window.location.reload(true);', function(resultText) {});
 
     this.takeControl();
   };
 
   TestSuite.prototype.testPushTimes = function(url) {
     var test = this;
     var pendingResourceCount = 2;
@@ skipping 11 matching lines @@
             resource.timing.pushStart < resource.timing.pushEnd,
             `pushStart should be before pushEnd (${resource.timing.pushStart} >= ${resource.timing.pushEnd})`);
         // The below assertion is just due to the way we generate times in the moch URLRequestJob and is not generally an invariant.
         test.assertTrue(resource.timing.pushEnd < resource.endTime, 'pushEnd should be before endTime');
         test.assertTrue(resource.startTime < resource.timing.pushEnd, 'pushEnd should be after startTime');
       }
       if (!--pendingResourceCount)
         test.releaseControl();
     }
 
-    this.addSniffer(WebInspector.NetworkDispatcher.prototype, '_finishNetworkRequest', finishResource, true);
+    this.addSniffer(SDK.NetworkDispatcher.prototype, '_finishNetworkRequest', finishResource, true);
 
     test.evaluateInConsole_('addImage(\'' + url + '\')', function(resultText) {});
     test.evaluateInConsole_('addImage(\'' + url + '?pushUseNullEndTime\')', function(resultText) {});
     this.takeControl();
   };
 
   TestSuite.prototype.testConsoleOnNavigateBack = function() {
 
     function filteredMessages() {
-       return WebInspector.multitargetConsoleModel.messages().filter(
-           a => a.source !== WebInspector.ConsoleMessage.MessageSource.Violation);
+       return SDK.multitargetConsoleModel.messages().filter(
+           a => a.source !== SDK.ConsoleMessage.MessageSource.Violation);
     }
 
     if (filteredMessages().length === 1)
       firstConsoleMessageReceived.call(this, null);
     else
-      WebInspector.multitargetConsoleModel.addEventListener(
-          WebInspector.ConsoleModel.Events.MessageAdded, firstConsoleMessageReceived, this);
+      SDK.multitargetConsoleModel.addEventListener(
+          SDK.ConsoleModel.Events.MessageAdded, firstConsoleMessageReceived, this);
 
     function firstConsoleMessageReceived(event) {
-      if (event && event.data.source === WebInspector.ConsoleMessage.MessageSource.Violation)
+      if (event && event.data.source === SDK.ConsoleMessage.MessageSource.Violation)
         return;
-      WebInspector.multitargetConsoleModel.removeEventListener(
-          WebInspector.ConsoleModel.Events.MessageAdded, firstConsoleMessageReceived, this);
+      SDK.multitargetConsoleModel.removeEventListener(
+          SDK.ConsoleModel.Events.MessageAdded, firstConsoleMessageReceived, this);
       this.evaluateInConsole_('clickLink();', didClickLink.bind(this));
     }
 
     function didClickLink() {
       // Check that there are no new messages(command is not a message).
       this.assertEquals(3, filteredMessages().length);
       this.evaluateInConsole_('history.back();', didNavigateBack.bind(this));
     }
 
     function didNavigateBack() {
@@ skipping 17 matching lines @@
     this.evaluateInConsole_('globalVar', didEvaluateInConsole.bind(this));
     this.takeControl();
   };
 
   TestSuite.prototype.testPauseInSharedWorkerInitialization1 = function() {
     // Make sure the worker is loaded.
     this.takeControl();
     this._waitForTargets(2, callback.bind(this));
 
     function callback() {
-      var target = WebInspector.targetManager.targets(WebInspector.Target.Capability.JS)[0];
+      var target = SDK.targetManager.targets(SDK.Target.Capability.JS)[0];
       InspectorBackendClass.deprecatedRunAfterPendingDispatches(this.releaseControl.bind(this));
     }
   };
 
   TestSuite.prototype.testPauseInSharedWorkerInitialization2 = function() {
     this.takeControl();
     this._waitForTargets(2, callback.bind(this));
 
     function callback() {
-      var target = WebInspector.targetManager.targets(WebInspector.Target.Capability.JS)[0];
-      var debuggerModel = WebInspector.DebuggerModel.fromTarget(target);
+      var target = SDK.targetManager.targets(SDK.Target.Capability.JS)[0];
+      var debuggerModel = SDK.DebuggerModel.fromTarget(target);
       if (debuggerModel.isPaused()) {
         this.releaseControl();
         return;
       }
       this._waitForScriptPause(this.releaseControl.bind(this));
     }
   };
 
   TestSuite.prototype.enableTouchEmulation = function() {
-    var deviceModeModel = new WebInspector.DeviceModeModel(function() {});
-    deviceModeModel._target = WebInspector.targetManager.mainTarget();
+    var deviceModeModel = new Emulation.DeviceModeModel(function() {});
+    deviceModeModel._target = SDK.targetManager.mainTarget();
     deviceModeModel._applyTouch(true, true);
   };
 
   TestSuite.prototype.enableAutoAttachToCreatedPages = function() {
-    WebInspector.settingForTest('autoAttachToCreatedPages').set(true);
+    Common.settingForTest('autoAttachToCreatedPages').set(true);
   };
 
   TestSuite.prototype.waitForDebuggerPaused = function() {
-    var debuggerModel = WebInspector.DebuggerModel.fromTarget(WebInspector.targetManager.mainTarget());
+    var debuggerModel = SDK.DebuggerModel.fromTarget(SDK.targetManager.mainTarget());
     if (debuggerModel.debuggerPausedDetails)
       return;
 
     this.takeControl();
     this._waitForScriptPause(this.releaseControl.bind(this));
   };
 
   TestSuite.prototype.switchToPanel = function(panelName) {
     this.showPanel(panelName).then(this.releaseControl.bind(this));
     this.takeControl();
   };
 
   // Regression test for crbug.com/370035.
   TestSuite.prototype.testDeviceMetricsOverrides = function() {
     const dumpPageMetrics = function() {
       return JSON.stringify(
           {width: window.innerWidth, height: window.innerHeight, deviceScaleFactor: window.devicePixelRatio});
     };
 
     var test = this;
 
     function testOverrides(params, metrics, callback) {
-      WebInspector.targetManager.mainTarget().emulationAgent().invoke_setDeviceMetricsOverride(params, getMetrics);
+      SDK.targetManager.mainTarget().emulationAgent().invoke_setDeviceMetricsOverride(params, getMetrics);
 
       function getMetrics() {
         test.evaluateInConsole_('(' + dumpPageMetrics.toString() + ')()', checkMetrics);
       }
 
       function checkMetrics(consoleResult) {
         test.assertEquals(
             '"' + JSON.stringify(metrics) + '"', consoleResult, 'Wrong metrics for params: ' + JSON.stringify(params));
         callback();
       }
@@ skipping 25 matching lines @@
 
     function finish() {
       test.releaseControl();
     }
 
     test.takeControl();
     step1();
   };
 
   TestSuite.prototype.testDispatchKeyEventDoesNotCrash = function() {
-    WebInspector.targetManager.mainTarget().inputAgent().invoke_dispatchKeyEvent(
+    SDK.targetManager.mainTarget().inputAgent().invoke_dispatchKeyEvent(
         {type: 'rawKeyDown', windowsVirtualKeyCode: 0x23, key: 'End'});
-    WebInspector.targetManager.mainTarget().inputAgent().invoke_dispatchKeyEvent(
+    SDK.targetManager.mainTarget().inputAgent().invoke_dispatchKeyEvent(
         {type: 'keyUp', windowsVirtualKeyCode: 0x23, key: 'End'});
   };
 
   TestSuite.prototype.testEmulateNetworkConditions = function() {
     var test = this;
 
     function testPreset(preset, messages, next) {
       function onConsoleMessage(event) {
         var index = messages.indexOf(event.data.messageText);
         if (index === -1) {
           test.fail('Unexpected message: ' + event.data.messageText);
           return;
         }
 
         messages.splice(index, 1);
         if (!messages.length) {
-          WebInspector.multitargetConsoleModel.removeEventListener(
-              WebInspector.ConsoleModel.Events.MessageAdded, onConsoleMessage, this);
+          SDK.multitargetConsoleModel.removeEventListener(
+              SDK.ConsoleModel.Events.MessageAdded, onConsoleMessage, this);
           next();
         }
       }
 
-      WebInspector.multitargetConsoleModel.addEventListener(
-          WebInspector.ConsoleModel.Events.MessageAdded, onConsoleMessage, this);
-      WebInspector.multitargetNetworkManager.setNetworkConditions(preset);
+      SDK.multitargetConsoleModel.addEventListener(
+          SDK.ConsoleModel.Events.MessageAdded, onConsoleMessage, this);
+      SDK.multitargetNetworkManager.setNetworkConditions(preset);
     }
 
     test.takeControl();
     step1();
 
     function step1() {
       testPreset(
-          WebInspector.NetworkConditionsSelector._presets[0],
+          Components.NetworkConditionsSelector._presets[0],
           ['offline event: online = false', 'connection change event: type = none; downlinkMax = 0'], step2);
     }
 
     function step2() {
       testPreset(
-          WebInspector.NetworkConditionsSelector._presets[2],
+          Components.NetworkConditionsSelector._presets[2],
           ['online event: online = true', 'connection change event: type = cellular; downlinkMax = 0.244140625'],
           step3);
     }
 
     function step3() {
       testPreset(
-          WebInspector.NetworkConditionsSelector._presets[8],
+          Components.NetworkConditionsSelector._presets[8],
           ['connection change event: type = wifi; downlinkMax = 30'], test.releaseControl.bind(test));
     }
   };
 
   TestSuite.prototype.testScreenshotRecording = function() {
     var test = this;
 
     function performActionsInPage(callback) {
       var count = 0;
       var div = document.createElement('div');
       div.setAttribute('style', 'left: 0px; top: 0px; width: 100px; height: 100px; position: absolute;');
       document.body.appendChild(div);
       requestAnimationFrame(frame);
       function frame() {
         var color = [0, 0, 0];
         color[count % 3] = 255;
         div.style.backgroundColor = 'rgb(' + color.join(',') + ')';
         if (++count > 10)
           requestAnimationFrame(callback);
         else
           requestAnimationFrame(frame);
       }
     }
 
-    var captureFilmStripSetting = WebInspector.settings.createSetting('timelineCaptureFilmStrip', false);
+    var captureFilmStripSetting = Common.settings.createSetting('timelineCaptureFilmStrip', false);
     captureFilmStripSetting.set(true);
     test.evaluateInConsole_(performActionsInPage.toString(), function() {});
     test.invokeAsyncWithTimeline_('performActionsInPage', onTimelineDone);
 
     function onTimelineDone() {
       captureFilmStripSetting.set(false);
-      var filmStripModel = new WebInspector.FilmStripModel(WebInspector.panels.timeline._tracingModel);
+      var filmStripModel = new Components.FilmStripModel(UI.panels.timeline._tracingModel);
       var frames = filmStripModel.frames();
       test.assertTrue(frames.length > 4 && typeof frames.length === 'number');
       loadFrameImages(frames);
     }
 
     function loadFrameImages(frames) {
       var readyImages = [];
       for (var frame of frames)
         frame.imageDataPromise().then(onGotImageData);
 
@@ skipping 43 matching lines @@
   };
 
   TestSuite.prototype.testSettings = function() {
     var test = this;
 
     createSettings();
     test.takeControl();
     setTimeout(reset, 0);
 
     function createSettings() {
-      var localSetting = WebInspector.settings.createSetting('local', undefined, true);
+      var localSetting = Common.settings.createSetting('local', undefined, true);
       localSetting.set({s: 'local', n: 1});
-      var globalSetting = WebInspector.settings.createSetting('global', undefined, false);
+      var globalSetting = Common.settings.createSetting('global', undefined, false);
       globalSetting.set({s: 'global', n: 2});
     }
 
     function reset() {
       Runtime.experiments.clearForTest();
       InspectorFrontendHost.getPreferences(gotPreferences);
     }
 
     function gotPreferences(prefs) {
-      WebInspector.Main._instanceForTest._createSettings(prefs);
+      Main.Main._instanceForTest._createSettings(prefs);
 
-      var localSetting = WebInspector.settings.createSetting('local', undefined, true);
+      var localSetting = Common.settings.createSetting('local', undefined, true);
       test.assertEquals('object', typeof localSetting.get());
       test.assertEquals('local', localSetting.get().s);
       test.assertEquals(1, localSetting.get().n);
-      var globalSetting = WebInspector.settings.createSetting('global', undefined, false);
+      var globalSetting = Common.settings.createSetting('global', undefined, false);
       test.assertEquals('object', typeof globalSetting.get());
       test.assertEquals('global', globalSetting.get().s);
       test.assertEquals(2, globalSetting.get().n);
       test.releaseControl();
     }
   };
 
   TestSuite.prototype.testWindowInitializedOnNavigateBack = function() {
-    var messages = WebInspector.multitargetConsoleModel.messages();
+    var messages = SDK.multitargetConsoleModel.messages();
     this.assertEquals(1, messages.length);
     var text = messages[0].messageText;
     if (text.indexOf('Uncaught') !== -1)
       this.fail(text);
   };
 
   TestSuite.prototype.testConsoleContextNames = function() {
     var test = this;
     test.takeControl();
     this.showPanel('console').then(() => this._waitForExecutionContexts(2, onExecutionContexts.bind(this)));
 
     function onExecutionContexts() {
-      var consoleView = WebInspector.ConsoleView.instance();
+      var consoleView = Console.ConsoleView.instance();
       var options = consoleView._consoleContextSelector._selectElement.options;
       var values = [];
       for (var i = 0; i < options.length; ++i)
         values.push(options[i].value.trim());
       test.assertEquals('top', values[0]);
       test.assertEquals('Simple content script', values[1]);
       test.releaseControl();
     }
   };
 
   TestSuite.prototype.testDevToolsSharedWorker = function() {
     this.takeControl();
-    WebInspector.TempFile.ensureTempStorageCleared().then(() => this.releaseControl());
+    Bindings.TempFile.ensureTempStorageCleared().then(() => this.releaseControl());
   };
 
   TestSuite.prototype.waitForTestResultsInConsole = function() {
-    var messages = WebInspector.multitargetConsoleModel.messages();
+    var messages = SDK.multitargetConsoleModel.messages();
     for (var i = 0; i < messages.length; ++i) {
       var text = messages[i].messageText;
       if (text === 'PASS')
         return;
       else if (/^FAIL/.test(text))
         this.fail(text);  // This will throw.
     }
     // Neither PASS nor FAIL, so wait for more messages.
     function onConsoleMessage(event) {
       var text = event.data.messageText;
       if (text === 'PASS')
         this.releaseControl();
       else if (/^FAIL/.test(text))
         this.fail(text);
     }
 
-    WebInspector.multitargetConsoleModel.addEventListener(
-        WebInspector.ConsoleModel.Events.MessageAdded, onConsoleMessage, this);
+    SDK.multitargetConsoleModel.addEventListener(
+        SDK.ConsoleModel.Events.MessageAdded, onConsoleMessage, this);
     this.takeControl();
   };
 
   TestSuite.prototype._overrideMethod = function(receiver, methodName, override) {
     var original = receiver[methodName];
     if (typeof original !== 'function') {
       this.fail(`TestSuite._overrideMethod: $[methodName] is not a function`);
       return;
     }
     receiver[methodName] = function() {
       try {
         var value = original.apply(receiver, arguments);
       } finally {
         receiver[methodName] = original;
       }
       override.apply(original, arguments);
       return value;
     };
   };
 
   TestSuite.prototype.startTimeline = function(callback) {
     var test = this;
     this.showPanel('timeline').then(function() {
-      var timeline = WebInspector.panels.timeline;
+      var timeline = UI.panels.timeline;
       test._overrideMethod(timeline, 'recordingStarted', callback);
       timeline._toggleRecording();
     });
   };
 
   TestSuite.prototype.stopTimeline = function(callback) {
-    var timeline = WebInspector.panels.timeline;
+    var timeline = UI.panels.timeline;
     this._overrideMethod(timeline, 'loadingComplete', callback);
     timeline._toggleRecording();
   };
 
   TestSuite.prototype.invokePageFunctionAsync = function(functionName, opt_args, callback_is_always_last) {
     var callback = arguments[arguments.length - 1];
     var doneMessage = `DONE: ${functionName}.${++this._asyncInvocationId}`;
     var argsString = arguments.length < 3 ?
         '' :
         Array.prototype.slice.call(arguments, 1, -1).map(arg => JSON.stringify(arg)).join(',') + ',';
     this.evaluateInConsole_(
         `${functionName}(${argsString} function() { console.log('${doneMessage}'); });`, function() {});
-    WebInspector.multitargetConsoleModel.addEventListener(
-        WebInspector.ConsoleModel.Events.MessageAdded, onConsoleMessage);
+    SDK.multitargetConsoleModel.addEventListener(
+        SDK.ConsoleModel.Events.MessageAdded, onConsoleMessage);
 
     function onConsoleMessage(event) {
       var text = event.data.messageText;
       if (text === doneMessage) {
-        WebInspector.multitargetConsoleModel.removeEventListener(
-            WebInspector.ConsoleModel.Events.MessageAdded, onConsoleMessage);
+        SDK.multitargetConsoleModel.removeEventListener(
+            SDK.ConsoleModel.Events.MessageAdded, onConsoleMessage);
         callback();
       }
     }
   };
 
   TestSuite.prototype.invokeAsyncWithTimeline_ = function(functionName, callback) {
     var test = this;
 
     this.startTimeline(onRecordingStarted);
 
     function onRecordingStarted() {
       test.invokePageFunctionAsync(functionName, pageActionsDone);
     }
 
     function pageActionsDone() {
       test.stopTimeline(callback);
     }
   };
 
   TestSuite.prototype.enableExperiment = function(name) {
     Runtime.experiments.enableForTest(name);
   };
 
   TestSuite.prototype.checkInputEventsPresent = function() {
     var expectedEvents = new Set(arguments);
-    var model = WebInspector.panels.timeline._model;
+    var model = UI.panels.timeline._model;
     var asyncEvents = model.mainThreadAsyncEvents();
-    var input = asyncEvents.get(WebInspector.TimelineModel.AsyncEventGroup.input) || [];
+    var input = asyncEvents.get(TimelineModel.TimelineModel.AsyncEventGroup.input) || [];
     var prefix = 'InputLatency::';
     for (var e of input) {
       if (!e.name.startsWith(prefix))
         continue;
       if (e.steps.length < 2)
         continue;
-      if (e.name.startsWith(prefix + 'Mouse') && typeof WebInspector.TimelineData.forEvent(e.steps[0]).timeWaitingForMainThread !== 'number')
+      if (e.name.startsWith(prefix + 'Mouse') && typeof TimelineModel.TimelineData.forEvent(e.steps[0]).timeWaitingForMainThread !== 'number')
         throw `Missing timeWaitingForMainThread on ${e.name}`;
       expectedEvents.delete(e.name.substr(prefix.length));
     }
     if (expectedEvents.size)
       throw 'Some expected events are not found: ' + Array.from(expectedEvents.keys()).join(',');
   };
 
   /**
    * Serializes array of uiSourceCodes to string.
-   * @param {!Array.<!WebInspectorUISourceCode>} uiSourceCodes
+   * @param {!Array.<!Workspace.UISourceCode>} uiSourceCodes
    * @return {string}
    */
   TestSuite.prototype.uiSourceCodesToString_ = function(uiSourceCodes) {
     var names = [];
     for (var i = 0; i < uiSourceCodes.length; i++)
       names.push('"' + uiSourceCodes[i].url() + '"');
     return names.join(',');
   };
 
   /**
    * Returns all loaded non anonymous uiSourceCodes.
-   * @return {!Array.<!WebInspectorUISourceCode>}
+   * @return {!Array.<!Workspace.UISourceCode>}
    */
   TestSuite.prototype.nonAnonymousUISourceCodes_ = function() {
     /**
-     * @param {!WebInspector.UISourceCode} uiSourceCode
+     * @param {!Workspace.UISourceCode} uiSourceCode
      */
     function filterOutService(uiSourceCode) {
       return !uiSourceCode.isFromServiceProject();
     }
 
-    var uiSourceCodes = WebInspector.workspace.uiSourceCodes();
+    var uiSourceCodes = Workspace.workspace.uiSourceCodes();
     return uiSourceCodes.filter(filterOutService);
   };
 
   /*
  * Evaluates the code in the console as if user typed it manually and invokes
  * the callback when the result message is received and added to the console.
  * @param {string} code
  * @param {function(string)} callback
  */
   TestSuite.prototype.evaluateInConsole_ = function(code, callback) {
     function innerEvaluate() {
-      WebInspector.context.removeFlavorChangeListener(WebInspector.ExecutionContext, showConsoleAndEvaluate, this);
-      var consoleView = WebInspector.ConsoleView.instance();
+      UI.context.removeFlavorChangeListener(SDK.ExecutionContext, showConsoleAndEvaluate, this);
+      var consoleView = Console.ConsoleView.instance();
       consoleView._prompt._appendCommand(code);
 
-      this.addSniffer(WebInspector.ConsoleView.prototype, '_consoleMessageAddedForTest', function(viewMessage) {
+      this.addSniffer(Console.ConsoleView.prototype, '_consoleMessageAddedForTest', function(viewMessage) {
         callback(viewMessage.toMessageElement().deepTextContent());
       }.bind(this));
     }
 
     function showConsoleAndEvaluate() {
-      WebInspector.console.showPromise().then(innerEvaluate.bind(this));
+      Common.console.showPromise().then(innerEvaluate.bind(this));
     }
 
-    if (!WebInspector.context.flavor(WebInspector.ExecutionContext)) {
-      WebInspector.context.addFlavorChangeListener(WebInspector.ExecutionContext, showConsoleAndEvaluate, this);
+    if (!UI.context.flavor(SDK.ExecutionContext)) {
+      UI.context.addFlavorChangeListener(SDK.ExecutionContext, showConsoleAndEvaluate, this);
       return;
     }
     showConsoleAndEvaluate.call(this);
   };
 
   /**
    * Checks that all expected scripts are present in the scripts list
    * in the Scripts panel.
    * @param {!Array.<string>} expected Regular expressions describing
    *     expected script names.
@@ skipping 13 matching lines @@
       }
     }
     return missing.length === 0;
   };
 
   /**
    * Waits for script pause, checks expectations, and invokes the callback.
    * @param {function():void} callback
    */
   TestSuite.prototype._waitForScriptPause = function(callback) {
-    this.addSniffer(WebInspector.DebuggerModel.prototype, '_pausedScript', callback);
+    this.addSniffer(SDK.DebuggerModel.prototype, '_pausedScript', callback);
   };
 
   /**
    * Waits until all the scripts are parsed and invokes the callback.
    */
   TestSuite.prototype._waitUntilScriptsAreParsed = function(expectedScripts, callback) {
     var test = this;
 
     function waitForAllScripts() {
       if (test._scriptsAreParsed(expectedScripts))
         callback();
       else
-        test.addSniffer(WebInspector.panels.sources.sourcesView(), '_addUISourceCode', waitForAllScripts);
+        test.addSniffer(UI.panels.sources.sourcesView(), '_addUISourceCode', waitForAllScripts);
     }
 
     waitForAllScripts();
   };
 
   TestSuite.prototype._waitForTargets = function(n, callback) {
     checkTargets.call(this);
 
     function checkTargets() {
-      if (WebInspector.targetManager.targets().length >= n)
+      if (SDK.targetManager.targets().length >= n)
         callback.call(null);
       else
-        this.addSniffer(WebInspector.TargetManager.prototype, 'addTarget', checkTargets.bind(this));
+        this.addSniffer(SDK.TargetManager.prototype, 'addTarget', checkTargets.bind(this));
     }
   };
 
   TestSuite.prototype._waitForExecutionContexts = function(n, callback) {
-    var runtimeModel = WebInspector.targetManager.mainTarget().runtimeModel;
+    var runtimeModel = SDK.targetManager.mainTarget().runtimeModel;
     checkForExecutionContexts.call(this);
 
     function checkForExecutionContexts() {
       if (runtimeModel.executionContexts().length >= n)
         callback.call(null);
       else
         this.addSniffer(
-            WebInspector.RuntimeModel.prototype, '_executionContextCreated', checkForExecutionContexts.bind(this));
+            SDK.RuntimeModel.prototype, '_executionContextCreated', checkForExecutionContexts.bind(this));
     }
   };
 
 
   window.uiTests = new TestSuite(window.domAutomationController);
 })(window);