DevTools: rename WebInspector into modules.

third_party/WebKit/Source/devtools/front_end/sdk/NetworkManager.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 13 matching lines @@
  * 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.
  */
 
 /**
  * @unrestricted
  */
-WebInspector.NetworkManager = class extends WebInspector.SDKModel {
+SDK.NetworkManager = class extends SDK.SDKModel {
   /**
-   * @param {!WebInspector.Target} target
+   * @param {!SDK.Target} target
    */
   constructor(target) {
-    super(WebInspector.NetworkManager, target);
-    this._dispatcher = new WebInspector.NetworkDispatcher(this);
+    super(SDK.NetworkManager, target);
+    this._dispatcher = new SDK.NetworkDispatcher(this);
     this._target = target;
     this._networkAgent = target.networkAgent();
     target.registerNetworkDispatcher(this._dispatcher);
-    if (WebInspector.moduleSetting('cacheDisabled').get())
+    if (Common.moduleSetting('cacheDisabled').get())
       this._networkAgent.setCacheDisabled(true);
-    if (WebInspector.moduleSetting('monitoringXHREnabled').get())
+    if (Common.moduleSetting('monitoringXHREnabled').get())
       this._networkAgent.setMonitoringXHREnabled(true);
 
     // Limit buffer when talking to a remote device.
     if (Runtime.queryParam('remoteFrontend') || Runtime.queryParam('ws'))
       this._networkAgent.enable(10000000, 5000000);
     else
       this._networkAgent.enable();
 
-    this._bypassServiceWorkerSetting = WebInspector.settings.createSetting('bypassServiceWorker', false);
+    this._bypassServiceWorkerSetting = Common.settings.createSetting('bypassServiceWorker', false);
     if (this._bypassServiceWorkerSetting.get())
       this._bypassServiceWorkerChanged();
     this._bypassServiceWorkerSetting.addChangeListener(this._bypassServiceWorkerChanged, this);
 
-    WebInspector.moduleSetting('cacheDisabled').addChangeListener(this._cacheDisabledSettingChanged, this);
+    Common.moduleSetting('cacheDisabled').addChangeListener(this._cacheDisabledSettingChanged, this);
   }
 
   /**
-   * @param {!WebInspector.Target} target
-   * @return {?WebInspector.NetworkManager}
+   * @param {!SDK.Target} target
+   * @return {?SDK.NetworkManager}
    */
   static fromTarget(target) {
-    return /** @type {?WebInspector.NetworkManager} */ (target.model(WebInspector.NetworkManager));
+    return /** @type {?SDK.NetworkManager} */ (target.model(SDK.NetworkManager));
   }
 
   /**
-   * @param {!WebInspector.NetworkManager.Conditions} conditions
+   * @param {!SDK.NetworkManager.Conditions} conditions
    * @return {!Protocol.Network.ConnectionType}
    * TODO(allada): this belongs to NetworkConditionsSelector, which should hardcode/guess it.
    */
   static _connectionType(conditions) {
     if (!conditions.download && !conditions.upload)
       return Protocol.Network.ConnectionType.None;
-    var types = WebInspector.NetworkManager._connectionTypes;
+    var types = SDK.NetworkManager._connectionTypes;
     if (!types) {
-      WebInspector.NetworkManager._connectionTypes = [];
-      types = WebInspector.NetworkManager._connectionTypes;
+      SDK.NetworkManager._connectionTypes = [];
+      types = SDK.NetworkManager._connectionTypes;
       types.push(['2g', Protocol.Network.ConnectionType.Cellular2g]);
       types.push(['3g', Protocol.Network.ConnectionType.Cellular3g]);
       types.push(['4g', Protocol.Network.ConnectionType.Cellular4g]);
       types.push(['bluetooth', Protocol.Network.ConnectionType.Bluetooth]);
       types.push(['wifi', Protocol.Network.ConnectionType.Wifi]);
       types.push(['wimax', Protocol.Network.ConnectionType.Wimax]);
     }
     for (var type of types) {
       if (conditions.title.toLowerCase().indexOf(type[0]) !== -1)
         return type[1];
     }
     return Protocol.Network.ConnectionType.Other;
   }
 
   /**
    * @param {string} url
-   * @return {!WebInspector.NetworkRequest}
+   * @return {!SDK.NetworkRequest}
    */
   inflightRequestForURL(url) {
     return this._dispatcher._inflightRequestsByURL[url];
   }
 
   /**
-   * @param {!WebInspector.Event} event
+   * @param {!Common.Event} event
    */
   _cacheDisabledSettingChanged(event) {
     var enabled = /** @type {boolean} */ (event.data);
     this._networkAgent.setCacheDisabled(enabled);
   }
 
   /**
    * @override
    */
   dispose() {
-    WebInspector.moduleSetting('cacheDisabled').removeChangeListener(this._cacheDisabledSettingChanged, this);
+    Common.moduleSetting('cacheDisabled').removeChangeListener(this._cacheDisabledSettingChanged, this);
   }
 
   _bypassServiceWorkerChanged() {
     this._networkAgent.setBypassServiceWorker(this._bypassServiceWorkerSetting.get());
   }
 };
 
 /** @enum {symbol} */
-WebInspector.NetworkManager.Events = {
+SDK.NetworkManager.Events = {
   RequestStarted: Symbol('RequestStarted'),
   RequestUpdated: Symbol('RequestUpdated'),
   RequestFinished: Symbol('RequestFinished'),
   RequestUpdateDropped: Symbol('RequestUpdateDropped'),
   ResponseReceived: Symbol('ResponseReceived')
 };
 
-WebInspector.NetworkManager._MIMETypes = {
+SDK.NetworkManager._MIMETypes = {
   'text/html': {'document': true},
   'text/xml': {'document': true},
   'text/plain': {'document': true},
   'application/xhtml+xml': {'document': true},
   'image/svg+xml': {'document': true},
   'text/css': {'stylesheet': true},
   'text/xsl': {'stylesheet': true},
   'text/vtt': {'texttrack': true},
 };
 
 
 /** @typedef {{download: number, upload: number, latency: number, title: string}} */
-WebInspector.NetworkManager.Conditions;
-/** @type {!WebInspector.NetworkManager.Conditions} */
-WebInspector.NetworkManager.NoThrottlingConditions = {
-  title: WebInspector.UIString('No throttling'),
+SDK.NetworkManager.Conditions;
+/** @type {!SDK.NetworkManager.Conditions} */
+SDK.NetworkManager.NoThrottlingConditions = {
+  title: Common.UIString('No throttling'),
   download: -1,
   upload: -1,
   latency: 0
 };
-/** @type {!WebInspector.NetworkManager.Conditions} */
-WebInspector.NetworkManager.OfflineConditions = {
-  title: WebInspector.UIString('Offline'),
+/** @type {!SDK.NetworkManager.Conditions} */
+SDK.NetworkManager.OfflineConditions = {
+  title: Common.UIString('Offline'),
   download: 0,
   upload: 0,
   latency: 0
 };
 
 
 /**
  * @implements {Protocol.NetworkDispatcher}
  * @unrestricted
  */
-WebInspector.NetworkDispatcher = class {
+SDK.NetworkDispatcher = class {
   constructor(manager) {
     this._manager = manager;
     this._inflightRequestsById = {};
     this._inflightRequestsByURL = {};
   }
 
   /**
    * @param {!Protocol.Network.Headers} headersMap
-   * @return {!Array.<!WebInspector.NetworkRequest.NameValue>}
+   * @return {!Array.<!SDK.NetworkRequest.NameValue>}
    */
   _headersMapToHeadersArray(headersMap) {
     var result = [];
     for (var name in headersMap) {
       var values = headersMap[name].split('\n');
       for (var i = 0; i < values.length; ++i)
         result.push({name: name, value: values[i]});
     }
     return result;
   }
 
   /**
-   * @param {!WebInspector.NetworkRequest} networkRequest
+   * @param {!SDK.NetworkRequest} networkRequest
    * @param {!Protocol.Network.Request} request
    */
   _updateNetworkRequestWithRequest(networkRequest, request) {
     networkRequest.requestMethod = request.method;
     networkRequest.setRequestHeaders(this._headersMapToHeadersArray(request.headers));
     networkRequest.requestFormData = request.postData;
     networkRequest.setInitialPriority(request.initialPriority);
     networkRequest.mixedContentType = request.mixedContentType || Protocol.Network.RequestMixedContentType.None;
   }
 
   /**
-   * @param {!WebInspector.NetworkRequest} networkRequest
+   * @param {!SDK.NetworkRequest} networkRequest
    * @param {!Protocol.Network.Response=} response
    */
   _updateNetworkRequestWithResponse(networkRequest, response) {
     if (response.url && networkRequest.url !== response.url)
       networkRequest.url = response.url;
     networkRequest.mimeType = response.mimeType;
     networkRequest.statusCode = response.status;
     networkRequest.statusText = response.statusText;
     networkRequest.responseHeaders = this._headersMapToHeadersArray(response.headers);
     if (response.encodedDataLength >= 0)
@@ skipping 16 matching lines @@
     if (response.fromDiskCache)
       networkRequest.setFromDiskCache();
     networkRequest.timing = response.timing;
 
     networkRequest.protocol = response.protocol;
 
     networkRequest.setSecurityState(response.securityState);
 
     if (!this._mimeTypeIsConsistentWithType(networkRequest)) {
       var consoleModel = this._manager._target.consoleModel;
-      consoleModel.addMessage(new WebInspector.ConsoleMessage(
-          consoleModel.target(), WebInspector.ConsoleMessage.MessageSource.Network,
-          WebInspector.ConsoleMessage.MessageLevel.Log,
-          WebInspector.UIString(
+      consoleModel.addMessage(new SDK.ConsoleMessage(
+          consoleModel.target(), SDK.ConsoleMessage.MessageSource.Network,
+          SDK.ConsoleMessage.MessageLevel.Log,
+          Common.UIString(
               'Resource interpreted as %s but transferred with MIME type %s: "%s".',
               networkRequest.resourceType().title(), networkRequest.mimeType, networkRequest.url),
-          WebInspector.ConsoleMessage.MessageType.Log, '', 0, 0, networkRequest.requestId));
+          SDK.ConsoleMessage.MessageType.Log, '', 0, 0, networkRequest.requestId));
     }
 
     if (response.securityDetails)
       networkRequest.setSecurityDetails(response.securityDetails);
   }
 
   /**
-   * @param {!WebInspector.NetworkRequest} networkRequest
+   * @param {!SDK.NetworkRequest} networkRequest
    * @return {boolean}
    */
   _mimeTypeIsConsistentWithType(networkRequest) {
     // If status is an error, content is likely to be of an inconsistent type,
     // as it's going to be an error message. We do not want to emit a warning
     // for this, though, as this will already be reported as resource loading failure.
     // Also, if a URL like http://localhost/wiki/load.php?debug=true&lang=en produces text/css and gets reloaded,
     // it is 304 Not Modified and its guessed mime-type is text/php, which is wrong.
     // Don't check for mime-types in 304-resources.
     if (networkRequest.hasErrorStatusCode() || networkRequest.statusCode === 304 || networkRequest.statusCode === 204)
       return true;
 
     var resourceType = networkRequest.resourceType();
-    if (resourceType !== WebInspector.resourceTypes.Stylesheet &&
-        resourceType !== WebInspector.resourceTypes.Document && resourceType !== WebInspector.resourceTypes.TextTrack) {
+    if (resourceType !== Common.resourceTypes.Stylesheet &&
+        resourceType !== Common.resourceTypes.Document && resourceType !== Common.resourceTypes.TextTrack) {
       return true;
     }
 
     if (!networkRequest.mimeType)
       return true;  // Might be not known for cached resources with null responses.
 
-    if (networkRequest.mimeType in WebInspector.NetworkManager._MIMETypes)
-      return resourceType.name() in WebInspector.NetworkManager._MIMETypes[networkRequest.mimeType];
+    if (networkRequest.mimeType in SDK.NetworkManager._MIMETypes)
+      return resourceType.name() in SDK.NetworkManager._MIMETypes[networkRequest.mimeType];
 
     return false;
   }
 
   /**
    * @override
    * @param {!Protocol.Network.RequestId} requestId
    * @param {!Protocol.Network.ResourcePriority} newPriority
    * @param {!Protocol.Network.Timestamp} timestamp
    */
@@ skipping 32 matching lines @@
       // FIXME: move this check to the backend.
       if (!redirectResponse)
         return;
       this.responseReceived(requestId, frameId, loaderId, time, Protocol.Page.ResourceType.Other, redirectResponse);
       networkRequest = this._appendRedirect(requestId, time, request.url);
     } else
       networkRequest = this._createNetworkRequest(requestId, frameId, loaderId, request.url, documentURL, initiator);
     networkRequest.hasNetworkData = true;
     this._updateNetworkRequestWithRequest(networkRequest, request);
     networkRequest.setIssueTime(time, wallTime);
-    networkRequest.setResourceType(WebInspector.resourceTypes[resourceType]);
+    networkRequest.setResourceType(Common.resourceTypes[resourceType]);
 
     this._startNetworkRequest(networkRequest);
   }
 
   /**
    * @override
    * @param {!Protocol.Network.RequestId} requestId
    */
   requestServedFromCache(requestId) {
     var networkRequest = this._inflightRequestsById[requestId];
@@ skipping 17 matching lines @@
     if (!networkRequest) {
       // We missed the requestWillBeSent.
       var eventData = {};
       eventData.url = response.url;
       eventData.frameId = frameId;
       eventData.loaderId = loaderId;
       eventData.resourceType = resourceType;
       eventData.mimeType = response.mimeType;
       var lastModifiedHeader = response.headers['last-modified'];
       eventData.lastModified = lastModifiedHeader ? new Date(lastModifiedHeader) : null;
-      this._manager.dispatchEventToListeners(WebInspector.NetworkManager.Events.RequestUpdateDropped, eventData);
+      this._manager.dispatchEventToListeners(SDK.NetworkManager.Events.RequestUpdateDropped, eventData);
       return;
     }
 
     networkRequest.responseReceivedTime = time;
-    networkRequest.setResourceType(WebInspector.resourceTypes[resourceType]);
+    networkRequest.setResourceType(Common.resourceTypes[resourceType]);
 
     this._updateNetworkRequestWithResponse(networkRequest, response);
 
     this._updateNetworkRequest(networkRequest);
-    this._manager.dispatchEventToListeners(WebInspector.NetworkManager.Events.ResponseReceived, networkRequest);
+    this._manager.dispatchEventToListeners(SDK.NetworkManager.Events.ResponseReceived, networkRequest);
   }
 
   /**
    * @override
    * @param {!Protocol.Network.RequestId} requestId
    * @param {!Protocol.Network.Timestamp} time
    * @param {number} dataLength
    * @param {number} encodedDataLength
    */
   dataReceived(requestId, time, dataLength, encodedDataLength) {
@@ skipping 30 matching lines @@
    * @param {string} localizedDescription
    * @param {boolean=} canceled
    * @param {!Protocol.Network.BlockedReason=} blockedReason
    */
   loadingFailed(requestId, time, resourceType, localizedDescription, canceled, blockedReason) {
     var networkRequest = this._inflightRequestsById[requestId];
     if (!networkRequest)
       return;
 
     networkRequest.failed = true;
-    networkRequest.setResourceType(WebInspector.resourceTypes[resourceType]);
+    networkRequest.setResourceType(Common.resourceTypes[resourceType]);
     networkRequest.canceled = canceled;
     if (blockedReason) {
       networkRequest.setBlockedReason(blockedReason);
       if (blockedReason === Protocol.Network.BlockedReason.Inspector) {
         var consoleModel = this._manager._target.consoleModel;
-        consoleModel.addMessage(new WebInspector.ConsoleMessage(
-            consoleModel.target(), WebInspector.ConsoleMessage.MessageSource.Network,
-            WebInspector.ConsoleMessage.MessageLevel.Warning,
-            WebInspector.UIString('Request was blocked by DevTools: "%s".', networkRequest.url),
-            WebInspector.ConsoleMessage.MessageType.Log, '', 0, 0, networkRequest.requestId));
+        consoleModel.addMessage(new SDK.ConsoleMessage(
+            consoleModel.target(), SDK.ConsoleMessage.MessageSource.Network,
+            SDK.ConsoleMessage.MessageLevel.Warning,
+            Common.UIString('Request was blocked by DevTools: "%s".', networkRequest.url),
+            SDK.ConsoleMessage.MessageType.Log, '', 0, 0, networkRequest.requestId));
       }
     }
     networkRequest.localizedFailDescription = localizedDescription;
     this._finishNetworkRequest(networkRequest, time, -1);
   }
 
   /**
    * @override
    * @param {!Protocol.Network.RequestId} requestId
    * @param {string} requestURL
    * @param {!Protocol.Network.Initiator=} initiator
    */
   webSocketCreated(requestId, requestURL, initiator) {
     var networkRequest =
-        new WebInspector.NetworkRequest(this._manager._target, requestId, requestURL, '', '', '', initiator || null);
-    networkRequest.setResourceType(WebInspector.resourceTypes.WebSocket);
+        new SDK.NetworkRequest(this._manager._target, requestId, requestURL, '', '', '', initiator || null);
+    networkRequest.setResourceType(Common.resourceTypes.WebSocket);
     this._startNetworkRequest(networkRequest);
   }
 
   /**
    * @override
    * @param {!Protocol.Network.RequestId} requestId
    * @param {!Protocol.Network.Timestamp} time
    * @param {!Protocol.Network.Timestamp} wallTime
    * @param {!Protocol.Network.WebSocketRequest} request
    */
@@ skipping 109 matching lines @@
     var networkRequest = this._inflightRequestsById[requestId];
     if (!networkRequest)
       return;
     networkRequest.addEventSourceMessage(time, eventName, eventId, data);
   }
 
   /**
    * @param {!Protocol.Network.RequestId} requestId
    * @param {!Protocol.Network.Timestamp} time
    * @param {string} redirectURL
-   * @return {!WebInspector.NetworkRequest}
+   * @return {!SDK.NetworkRequest}
    */
   _appendRedirect(requestId, time, redirectURL) {
     var originalNetworkRequest = this._inflightRequestsById[requestId];
     var previousRedirects = originalNetworkRequest.redirects || [];
     originalNetworkRequest.requestId = requestId + ':redirected.' + previousRedirects.length;
     delete originalNetworkRequest.redirects;
     if (previousRedirects.length > 0)
       originalNetworkRequest.redirectSource = previousRedirects[previousRedirects.length - 1];
     this._finishNetworkRequest(originalNetworkRequest, time, -1);
     var newNetworkRequest = this._createNetworkRequest(
         requestId, originalNetworkRequest.frameId, originalNetworkRequest.loaderId, redirectURL,
         originalNetworkRequest.documentURL, originalNetworkRequest.initiator());
     newNetworkRequest.redirects = previousRedirects.concat(originalNetworkRequest);
     return newNetworkRequest;
   }
 
   /**
-   * @param {!WebInspector.NetworkRequest} networkRequest
+   * @param {!SDK.NetworkRequest} networkRequest
    */
   _startNetworkRequest(networkRequest) {
     this._inflightRequestsById[networkRequest.requestId] = networkRequest;
     this._inflightRequestsByURL[networkRequest.url] = networkRequest;
-    this._dispatchEventToListeners(WebInspector.NetworkManager.Events.RequestStarted, networkRequest);
+    this._dispatchEventToListeners(SDK.NetworkManager.Events.RequestStarted, networkRequest);
   }
 
   /**
-   * @param {!WebInspector.NetworkRequest} networkRequest
+   * @param {!SDK.NetworkRequest} networkRequest
    */
   _updateNetworkRequest(networkRequest) {
-    this._dispatchEventToListeners(WebInspector.NetworkManager.Events.RequestUpdated, networkRequest);
+    this._dispatchEventToListeners(SDK.NetworkManager.Events.RequestUpdated, networkRequest);
   }
 
   /**
-   * @param {!WebInspector.NetworkRequest} networkRequest
+   * @param {!SDK.NetworkRequest} networkRequest
    * @param {!Protocol.Network.Timestamp} finishTime
    * @param {number} encodedDataLength
    */
   _finishNetworkRequest(networkRequest, finishTime, encodedDataLength) {
     networkRequest.endTime = finishTime;
     networkRequest.finished = true;
     if (encodedDataLength >= 0)
       networkRequest.setTransferSize(encodedDataLength);
-    this._dispatchEventToListeners(WebInspector.NetworkManager.Events.RequestFinished, networkRequest);
+    this._dispatchEventToListeners(SDK.NetworkManager.Events.RequestFinished, networkRequest);
     delete this._inflightRequestsById[networkRequest.requestId];
     delete this._inflightRequestsByURL[networkRequest.url];
   }
 
   /**
    * @param {string} eventType
-   * @param {!WebInspector.NetworkRequest} networkRequest
+   * @param {!SDK.NetworkRequest} networkRequest
    */
   _dispatchEventToListeners(eventType, networkRequest) {
     this._manager.dispatchEventToListeners(eventType, networkRequest);
   }
 
   /**
    * @param {!Protocol.Network.RequestId} requestId
    * @param {string} frameId
    * @param {!Protocol.Network.LoaderId} loaderId
    * @param {string} url
    * @param {string} documentURL
    * @param {?Protocol.Network.Initiator} initiator
    */
   _createNetworkRequest(requestId, frameId, loaderId, url, documentURL, initiator) {
-    return new WebInspector.NetworkRequest(
+    return new SDK.NetworkRequest(
         this._manager._target, requestId, url, documentURL, frameId, loaderId, initiator);
   }
 };
 
 /**
- * @implements {WebInspector.TargetManager.Observer}
+ * @implements {SDK.TargetManager.Observer}
  * @unrestricted
  */
-WebInspector.MultitargetNetworkManager = class extends WebInspector.Object {
+SDK.MultitargetNetworkManager = class extends Common.Object {
   constructor() {
     super();
 
     /** @type {!Set<string>} */
     this._blockedURLs = new Set();
-    this._blockedSetting = WebInspector.moduleSetting('blockedURLs');
+    this._blockedSetting = Common.moduleSetting('blockedURLs');
     this._blockedSetting.addChangeListener(this._updateBlockedURLs, this);
     this._blockedSetting.set([]);
     this._updateBlockedURLs();
 
     this._userAgentOverride = '';
     /** @type {!Set<!Protocol.NetworkAgent>} */
     this._agents = new Set();
-    /** @type {!WebInspector.NetworkManager.Conditions} */
-    this._networkConditions = WebInspector.NetworkManager.NoThrottlingConditions;
+    /** @type {!SDK.NetworkManager.Conditions} */
+    this._networkConditions = SDK.NetworkManager.NoThrottlingConditions;
 
-    WebInspector.targetManager.observeTargets(this, WebInspector.Target.Capability.Network);
+    SDK.targetManager.observeTargets(this, SDK.Target.Capability.Network);
   }
 
   /**
    * @param {string} uaString
    * @return {string}
    */
   static patchUserAgentWithChromeVersion(uaString) {
     // Patches Chrome/CriOS version from user agent ("1.2.3.4" when user agent is: "Chrome/1.2.3.4").
     var chromeRegex = new RegExp('(?:^|\\W)Chrome/(\\S+)');
     var chromeMatch = navigator.userAgent.match(chromeRegex);
     if (chromeMatch && chromeMatch.length > 1)
       return String.sprintf(uaString, chromeMatch[1]);
     return uaString;
   }
 
   /**
    * @override
-   * @param {!WebInspector.Target} target
+   * @param {!SDK.Target} target
    */
   targetAdded(target) {
     var networkAgent = target.networkAgent();
     if (this._extraHeaders)
       networkAgent.setExtraHTTPHeaders(this._extraHeaders);
     if (this._currentUserAgent())
       networkAgent.setUserAgentOverride(this._currentUserAgent());
     for (var url of this._blockedURLs)
       networkAgent.addBlockedURL(url);
     this._agents.add(networkAgent);
     if (this.isThrottling())
       this._updateNetworkConditions(networkAgent);
   }
 
   /**
    * @override
-   * @param {!WebInspector.Target} target
+   * @param {!SDK.Target} target
    */
   targetRemoved(target) {
     this._agents.delete(target.networkAgent());
   }
 
   /**
    * @return {boolean}
    */
   isThrottling() {
     return this._networkConditions.download >= 0 || this._networkConditions.upload >= 0 ||
         this._networkConditions.latency > 0;
   }
 
   /**
    * @return {boolean}
    */
   isOffline() {
     return !this._networkConditions.download && !this._networkConditions.upload;
   }
 
   /**
-   * @param {!WebInspector.NetworkManager.Conditions} conditions
+   * @param {!SDK.NetworkManager.Conditions} conditions
    */
   setNetworkConditions(conditions) {
     this._networkConditions = conditions;
     for (var agent of this._agents)
       this._updateNetworkConditions(agent);
-    this.dispatchEventToListeners(WebInspector.MultitargetNetworkManager.Events.ConditionsChanged);
+    this.dispatchEventToListeners(SDK.MultitargetNetworkManager.Events.ConditionsChanged);
   }
 
   /**
-   * @return {!WebInspector.NetworkManager.Conditions}
+   * @return {!SDK.NetworkManager.Conditions}
    */
   networkConditions() {
     return this._networkConditions;
   }
 
   /**
    * @param {!Protocol.NetworkAgent} networkAgent
    */
   _updateNetworkConditions(networkAgent) {
     var conditions = this._networkConditions;
     if (!this.isThrottling()) {
       networkAgent.emulateNetworkConditions(false, 0, 0, 0);
     } else {
       networkAgent.emulateNetworkConditions(
           this.isOffline(), conditions.latency, conditions.download < 0 ? 0 : conditions.download,
-          conditions.upload < 0 ? 0 : conditions.upload, WebInspector.NetworkManager._connectionType(conditions));
+          conditions.upload < 0 ? 0 : conditions.upload, SDK.NetworkManager._connectionType(conditions));
     }
   }
 
   /**
    * @param {!Protocol.Network.Headers} headers
    */
   setExtraHTTPHeaders(headers) {
     this._extraHeaders = headers;
     for (var agent of this._agents)
       agent.setExtraHTTPHeaders(this._extraHeaders);
   }
 
   /**
    * @return {string}
    */
   _currentUserAgent() {
     return this._customUserAgent ? this._customUserAgent : this._userAgentOverride;
   }
 
   _updateUserAgentOverride() {
     var userAgent = this._currentUserAgent();
-    WebInspector.ResourceLoader.targetUserAgent = userAgent;
+    Host.ResourceLoader.targetUserAgent = userAgent;
     for (var agent of this._agents)
       agent.setUserAgentOverride(userAgent);
   }
 
   /**
    * @param {string} userAgent
    */
   setUserAgentOverride(userAgent) {
     if (this._userAgentOverride === userAgent)
       return;
     this._userAgentOverride = userAgent;
     if (!this._customUserAgent)
       this._updateUserAgentOverride();
-    this.dispatchEventToListeners(WebInspector.MultitargetNetworkManager.Events.UserAgentChanged);
+    this.dispatchEventToListeners(SDK.MultitargetNetworkManager.Events.UserAgentChanged);
   }
 
   /**
    * @return {string}
    */
   userAgentOverride() {
     return this._userAgentOverride;
   }
 
   /**
@@ skipping 42 matching lines @@
   clearBrowserCookies() {
     for (var agent of this._agents)
       agent.clearBrowserCookies();
   }
 
   /**
    * @param {string} origin
    * @param {function(!Array<string>)} callback
    */
   getCertificate(origin, callback) {
-    var target = WebInspector.targetManager.mainTarget();
+    var target = SDK.targetManager.mainTarget();
     target.networkAgent().getCertificate(origin, mycallback);
 
     /**
      * @param {?Protocol.Error} error
      * @param {!Array<string>} certificate
      */
     function mycallback(error, certificate) {
       callback(error ? [] : certificate);
     }
   }
 
   /**
    * @param {string} url
    * @param {function(number, !Object.<string, string>, string)} callback
    */
   loadResource(url, callback) {
     var headers = {};
 
     var currentUserAgent = this._currentUserAgent();
     if (currentUserAgent)
       headers['User-Agent'] = currentUserAgent;
 
-    if (WebInspector.moduleSetting('cacheDisabled').get())
+    if (Common.moduleSetting('cacheDisabled').get())
       headers['Cache-Control'] = 'no-cache';
 
-    WebInspector.ResourceLoader.load(url, headers, callback);
+    Host.ResourceLoader.load(url, headers, callback);
   }
 };
 
 /** @enum {symbol} */
-WebInspector.MultitargetNetworkManager.Events = {
+SDK.MultitargetNetworkManager.Events = {
   ConditionsChanged: Symbol('ConditionsChanged'),
   UserAgentChanged: Symbol('UserAgentChanged')
 };
 
 
 /**
- * @type {!WebInspector.MultitargetNetworkManager}
+ * @type {!SDK.MultitargetNetworkManager}
  */
-WebInspector.multitargetNetworkManager;
+SDK.multitargetNetworkManager;