DevTools: rename WebInspector into modules.

third_party/WebKit/Source/devtools/front_end/sdk/ServiceWorkerManager.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.ServiceWorkerManager = class extends WebInspector.SDKObject {
+SDK.ServiceWorkerManager = class extends SDK.SDKObject {
   /**
-   * @param {!WebInspector.Target} target
-   * @param {!WebInspector.SubTargetsManager} subTargetsManager
+   * @param {!SDK.Target} target
+   * @param {!SDK.SubTargetsManager} subTargetsManager
    */
   constructor(target, subTargetsManager) {
     super(target);
-    target.registerServiceWorkerDispatcher(new WebInspector.ServiceWorkerDispatcher(this));
+    target.registerServiceWorkerDispatcher(new SDK.ServiceWorkerDispatcher(this));
     this._lastAnonymousTargetId = 0;
     this._agent = target.serviceWorkerAgent();
-    /** @type {!Map.<string, !WebInspector.ServiceWorkerRegistration>} */
+    /** @type {!Map.<string, !SDK.ServiceWorkerRegistration>} */
     this._registrations = new Map();
     this.enable();
-    this._forceUpdateSetting = WebInspector.settings.createSetting('serviceWorkerUpdateOnReload', false);
+    this._forceUpdateSetting = Common.settings.createSetting('serviceWorkerUpdateOnReload', false);
     if (this._forceUpdateSetting.get())
       this._forceUpdateSettingChanged();
     this._forceUpdateSetting.addChangeListener(this._forceUpdateSettingChanged, this);
-    new WebInspector.ServiceWorkerContextNamer(target, this, subTargetsManager);
+    new SDK.ServiceWorkerContextNamer(target, this, subTargetsManager);
   }
 
   enable() {
     if (this._enabled)
       return;
     this._enabled = true;
     this._agent.enable();
   }
 
   disable() {
     if (!this._enabled)
       return;
     this._enabled = false;
     this._registrations.clear();
     this._agent.disable();
   }
 
   /**
-   * @return {!Map.<string, !WebInspector.ServiceWorkerRegistration>}
+   * @return {!Map.<string, !SDK.ServiceWorkerRegistration>}
    */
   registrations() {
     return this._registrations;
   }
 
   /**
    * @param {string} versionId
-   * @return {?WebInspector.ServiceWorkerVersion}
+   * @return {?SDK.ServiceWorkerVersion}
    */
   findVersion(versionId) {
     for (var registration of this.registrations().values()) {
       var version = registration.versions.get(versionId);
       if (version)
         return version;
     }
     return null;
   }
 
   /**
    * @param {string} registrationId
    */
   deleteRegistration(registrationId) {
     var registration = this._registrations.get(registrationId);
     if (!registration)
       return;
     if (registration._isRedundant()) {
       this._registrations.delete(registrationId);
-      this.dispatchEventToListeners(WebInspector.ServiceWorkerManager.Events.RegistrationDeleted, registration);
+      this.dispatchEventToListeners(SDK.ServiceWorkerManager.Events.RegistrationDeleted, registration);
       return;
     }
     registration._deleting = true;
     for (var version of registration.versions.values())
       this.stopWorker(version.id);
     this._unregister(registration.scopeURL);
   }
 
   /**
    * @param {string} registrationId
    */
   updateRegistration(registrationId) {
     var registration = this._registrations.get(registrationId);
     if (!registration)
       return;
     this._agent.updateRegistration(registration.scopeURL);
   }
 
   /**
    * @param {string} registrationId
    * @param {string} data
    */
   deliverPushMessage(registrationId, data) {
     var registration = this._registrations.get(registrationId);
     if (!registration)
       return;
-    var origin = WebInspector.ParsedURL.extractOrigin(registration.scopeURL);
+    var origin = Common.ParsedURL.extractOrigin(registration.scopeURL);
     this._agent.deliverPushMessage(origin, registrationId, data);
   }
 
   /**
    * @param {string} registrationId
    * @param {string} tag
    * @param {boolean} lastChance
    */
   dispatchSyncEvent(registrationId, tag, lastChance) {
     var registration = this._registrations.get(registrationId);
     if (!registration)
       return;
-    var origin = WebInspector.ParsedURL.extractOrigin(registration.scopeURL);
+    var origin = Common.ParsedURL.extractOrigin(registration.scopeURL);
     this._agent.dispatchSyncEvent(origin, registrationId, tag, lastChance);
   }
 
   /**
    * @param {string} scope
    */
   _unregister(scope) {
     this._agent.unregister(scope);
   }
 
@@ skipping 25 matching lines @@
     this._agent.inspectWorker(versionId);
   }
 
   /**
    * @param {!Array.<!Protocol.ServiceWorker.ServiceWorkerRegistration>} registrations
    */
   _workerRegistrationUpdated(registrations) {
     for (var payload of registrations) {
       var registration = this._registrations.get(payload.registrationId);
       if (!registration) {
-        registration = new WebInspector.ServiceWorkerRegistration(payload);
+        registration = new SDK.ServiceWorkerRegistration(payload);
         this._registrations.set(payload.registrationId, registration);
-        this.dispatchEventToListeners(WebInspector.ServiceWorkerManager.Events.RegistrationUpdated, registration);
+        this.dispatchEventToListeners(SDK.ServiceWorkerManager.Events.RegistrationUpdated, registration);
         continue;
       }
       registration._update(payload);
 
       if (registration._shouldBeRemoved()) {
         this._registrations.delete(registration.id);
-        this.dispatchEventToListeners(WebInspector.ServiceWorkerManager.Events.RegistrationDeleted, registration);
+        this.dispatchEventToListeners(SDK.ServiceWorkerManager.Events.RegistrationDeleted, registration);
       } else {
-        this.dispatchEventToListeners(WebInspector.ServiceWorkerManager.Events.RegistrationUpdated, registration);
+        this.dispatchEventToListeners(SDK.ServiceWorkerManager.Events.RegistrationUpdated, registration);
       }
     }
   }
 
   /**
    * @param {!Array.<!Protocol.ServiceWorker.ServiceWorkerVersion>} versions
    */
   _workerVersionUpdated(versions) {
-    /** @type {!Set.<!WebInspector.ServiceWorkerRegistration>} */
+    /** @type {!Set.<!SDK.ServiceWorkerRegistration>} */
     var registrations = new Set();
     for (var payload of versions) {
       var registration = this._registrations.get(payload.registrationId);
       if (!registration)
         continue;
       registration._updateVersion(payload);
       registrations.add(registration);
     }
     for (var registration of registrations) {
       if (registration._shouldBeRemoved()) {
         this._registrations.delete(registration.id);
-        this.dispatchEventToListeners(WebInspector.ServiceWorkerManager.Events.RegistrationDeleted, registration);
+        this.dispatchEventToListeners(SDK.ServiceWorkerManager.Events.RegistrationDeleted, registration);
       } else {
-        this.dispatchEventToListeners(WebInspector.ServiceWorkerManager.Events.RegistrationUpdated, registration);
+        this.dispatchEventToListeners(SDK.ServiceWorkerManager.Events.RegistrationUpdated, registration);
       }
     }
   }
 
   /**
    * @param {!Protocol.ServiceWorker.ServiceWorkerErrorMessage} payload
    */
   _workerErrorReported(payload) {
     var registration = this._registrations.get(payload.registrationId);
     if (!registration)
       return;
     registration.errors.push(payload);
     this.dispatchEventToListeners(
-        WebInspector.ServiceWorkerManager.Events.RegistrationErrorAdded, {registration: registration, error: payload});
+        SDK.ServiceWorkerManager.Events.RegistrationErrorAdded, {registration: registration, error: payload});
   }
 
   /**
-   * @return {!WebInspector.Setting}
+   * @return {!Common.Setting}
    */
   forceUpdateOnReloadSetting() {
     return this._forceUpdateSetting;
   }
 
   _forceUpdateSettingChanged() {
     this._agent.setForceUpdateOnPageLoad(this._forceUpdateSetting.get());
   }
 };
 
 /** @enum {symbol} */
-WebInspector.ServiceWorkerManager.Events = {
+SDK.ServiceWorkerManager.Events = {
   RegistrationUpdated: Symbol('RegistrationUpdated'),
   RegistrationErrorAdded: Symbol('RegistrationErrorAdded'),
   RegistrationDeleted: Symbol('RegistrationDeleted')
 };
 
 /**
  * @implements {Protocol.ServiceWorkerDispatcher}
  * @unrestricted
  */
-WebInspector.ServiceWorkerDispatcher = class {
+SDK.ServiceWorkerDispatcher = class {
   /**
-   * @param {!WebInspector.ServiceWorkerManager} manager
+   * @param {!SDK.ServiceWorkerManager} manager
    */
   constructor(manager) {
     this._manager = manager;
   }
 
   /**
    * @override
    * @param {!Array.<!Protocol.ServiceWorker.ServiceWorkerRegistration>} registrations
    */
   workerRegistrationUpdated(registrations) {
@@ skipping 13 matching lines @@
    * @param {!Protocol.ServiceWorker.ServiceWorkerErrorMessage} errorMessage
    */
   workerErrorReported(errorMessage) {
     this._manager._workerErrorReported(errorMessage);
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.ServiceWorkerVersion = class {
+SDK.ServiceWorkerVersion = class {
   /**
-   * @param {!WebInspector.ServiceWorkerRegistration} registration
+   * @param {!SDK.ServiceWorkerRegistration} registration
    * @param {!Protocol.ServiceWorker.ServiceWorkerVersion} payload
    */
   constructor(registration, payload) {
     this.registration = registration;
     this._update(payload);
   }
 
   /**
    * @param {!Protocol.ServiceWorker.ServiceWorkerVersion} payload
    */
   _update(payload) {
     this.id = payload.versionId;
     this.scriptURL = payload.scriptURL;
-    var parsedURL = new WebInspector.ParsedURL(payload.scriptURL);
+    var parsedURL = new Common.ParsedURL(payload.scriptURL);
     this.securityOrigin = parsedURL.securityOrigin();
     this.runningStatus = payload.runningStatus;
     this.status = payload.status;
     this.scriptLastModified = payload.scriptLastModified;
     this.scriptResponseTime = payload.scriptResponseTime;
     this.controlledClients = [];
     for (var i = 0; i < payload.controlledClients.length; ++i)
       this.controlledClients.push(payload.controlledClients[i]);
     this.targetId = payload.targetId || null;
   }
@@ skipping 81 matching lines @@
    */
   isRedundant() {
     return this.status === Protocol.ServiceWorker.ServiceWorkerVersionStatus.Redundant;
   }
 
   /**
    * @return {string}
    */
   mode() {
     if (this.isNew() || this.isInstalling())
-      return WebInspector.ServiceWorkerVersion.Modes.Installing;
+      return SDK.ServiceWorkerVersion.Modes.Installing;
     else if (this.isInstalled())
-      return WebInspector.ServiceWorkerVersion.Modes.Waiting;
+      return SDK.ServiceWorkerVersion.Modes.Waiting;
     else if (this.isActivating() || this.isActivated())
-      return WebInspector.ServiceWorkerVersion.Modes.Active;
-    return WebInspector.ServiceWorkerVersion.Modes.Redundant;
+      return SDK.ServiceWorkerVersion.Modes.Active;
+    return SDK.ServiceWorkerVersion.Modes.Redundant;
   }
 };
 
 /**
  * @enum {string}
  */
-WebInspector.ServiceWorkerVersion.Modes = {
+SDK.ServiceWorkerVersion.Modes = {
   Installing: 'installing',
   Waiting: 'waiting',
   Active: 'active',
   Redundant: 'redundant'
 };
 
 /**
  * @unrestricted
  */
-WebInspector.ServiceWorkerRegistration = class {
+SDK.ServiceWorkerRegistration = class {
   /**
    * @param {!Protocol.ServiceWorker.ServiceWorkerRegistration} payload
    */
   constructor(payload) {
     this._update(payload);
-    /** @type {!Map.<string, !WebInspector.ServiceWorkerVersion>} */
+    /** @type {!Map.<string, !SDK.ServiceWorkerVersion>} */
     this.versions = new Map();
     this._deleting = false;
     /** @type {!Array<!Protocol.ServiceWorker.ServiceWorkerErrorMessage>} */
     this.errors = [];
   }
 
   /**
    * @param {!Protocol.ServiceWorker.ServiceWorkerRegistration} payload
    */
   _update(payload) {
     this._fingerprint = Symbol('fingerprint');
     this.id = payload.registrationId;
     this.scopeURL = payload.scopeURL;
-    var parsedURL = new WebInspector.ParsedURL(payload.scopeURL);
+    var parsedURL = new Common.ParsedURL(payload.scopeURL);
     this.securityOrigin = parsedURL.securityOrigin();
     this.isDeleted = payload.isDeleted;
     this.forceUpdateOnPageLoad = payload.forceUpdateOnPageLoad;
   }
 
   /**
    * @return {symbol}
    */
   fingerprint() {
     return this._fingerprint;
   }
 
   /**
-   * @return {!Map<string, !WebInspector.ServiceWorkerVersion>}
+   * @return {!Map<string, !SDK.ServiceWorkerVersion>}
    */
   versionsByMode() {
-    /** @type {!Map<string, !WebInspector.ServiceWorkerVersion>} */
+    /** @type {!Map<string, !SDK.ServiceWorkerVersion>} */
     var result = new Map();
     for (var version of this.versions.values())
       result.set(version.mode(), version);
     return result;
   }
 
   /**
    * @param {!Protocol.ServiceWorker.ServiceWorkerVersion} payload
-   * @return {!WebInspector.ServiceWorkerVersion}
+   * @return {!SDK.ServiceWorkerVersion}
    */
   _updateVersion(payload) {
     this._fingerprint = Symbol('fingerprint');
     var version = this.versions.get(payload.versionId);
     if (!version) {
-      version = new WebInspector.ServiceWorkerVersion(this, payload);
+      version = new SDK.ServiceWorkerVersion(this, payload);
       this.versions.set(payload.versionId, version);
       return version;
     }
     version._update(payload);
     return version;
   }
 
   /**
    * @return {boolean}
    */
@@ skipping 14 matching lines @@
 
   clearErrors() {
     this._fingerprint = Symbol('fingerprint');
     this.errors = [];
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.ServiceWorkerContextNamer = class {
+SDK.ServiceWorkerContextNamer = class {
   /**
-   * @param {!WebInspector.Target} target
-   * @param {!WebInspector.ServiceWorkerManager} serviceWorkerManager
-   * @param {!WebInspector.SubTargetsManager} subTargetsManager
+   * @param {!SDK.Target} target
+   * @param {!SDK.ServiceWorkerManager} serviceWorkerManager
+   * @param {!SDK.SubTargetsManager} subTargetsManager
    */
   constructor(target, serviceWorkerManager, subTargetsManager) {
     this._target = target;
     this._serviceWorkerManager = serviceWorkerManager;
     this._subTargetsManager = subTargetsManager;
-    /** @type {!Map<string, !WebInspector.ServiceWorkerVersion>} */
+    /** @type {!Map<string, !SDK.ServiceWorkerVersion>} */
     this._versionByTargetId = new Map();
     serviceWorkerManager.addEventListener(
-        WebInspector.ServiceWorkerManager.Events.RegistrationUpdated, this._registrationsUpdated, this);
+        SDK.ServiceWorkerManager.Events.RegistrationUpdated, this._registrationsUpdated, this);
     serviceWorkerManager.addEventListener(
-        WebInspector.ServiceWorkerManager.Events.RegistrationDeleted, this._registrationsUpdated, this);
-    WebInspector.targetManager.addModelListener(
-        WebInspector.RuntimeModel, WebInspector.RuntimeModel.Events.ExecutionContextCreated,
+        SDK.ServiceWorkerManager.Events.RegistrationDeleted, this._registrationsUpdated, this);
+    SDK.targetManager.addModelListener(
+        SDK.RuntimeModel, SDK.RuntimeModel.Events.ExecutionContextCreated,
         this._executionContextCreated, this);
   }
 
   /**
-   * @param {!WebInspector.Event} event
+   * @param {!Common.Event} event
    */
   _registrationsUpdated(event) {
     this._versionByTargetId.clear();
     var registrations = this._serviceWorkerManager.registrations().valuesArray();
     for (var registration of registrations) {
       var versions = registration.versions.valuesArray();
       for (var version of versions) {
         if (version.targetId)
           this._versionByTargetId.set(version.targetId, version);
       }
     }
     this._updateAllContextLabels();
   }
 
   /**
-   * @param {!WebInspector.Event} event
+   * @param {!Common.Event} event
    */
   _executionContextCreated(event) {
-    var executionContext = /** @type {!WebInspector.ExecutionContext} */ (event.data);
+    var executionContext = /** @type {!SDK.ExecutionContext} */ (event.data);
     var serviceWorkerTargetId = this._serviceWorkerTargetIdForWorker(executionContext.target());
     if (!serviceWorkerTargetId)
       return;
     this._updateContextLabel(executionContext, this._versionByTargetId.get(serviceWorkerTargetId) || null);
   }
 
   /**
-   * @param {!WebInspector.Target} target
+   * @param {!SDK.Target} target
    * @return {?string}
    */
   _serviceWorkerTargetIdForWorker(target) {
     var parent = target.parentTarget();
     if (!parent || parent.parentTarget() !== this._target)
       return null;
     var targetInfo = this._subTargetsManager.targetInfo(parent);
     if (!targetInfo || targetInfo.type !== 'service_worker')
       return null;
     return targetInfo.id;
   }
 
   _updateAllContextLabels() {
-    for (var target of WebInspector.targetManager.targets()) {
+    for (var target of SDK.targetManager.targets()) {
       var serviceWorkerTargetId = this._serviceWorkerTargetIdForWorker(target);
       if (!serviceWorkerTargetId)
         continue;
       var version = this._versionByTargetId.get(serviceWorkerTargetId) || null;
       for (var context of target.runtimeModel.executionContexts())
         this._updateContextLabel(context, version);
     }
   }
 
   /**
-   * @param {!WebInspector.ExecutionContext} context
-   * @param {?WebInspector.ServiceWorkerVersion} version
+   * @param {!SDK.ExecutionContext} context
+   * @param {?SDK.ServiceWorkerVersion} version
    */
   _updateContextLabel(context, version) {
     var parsedUrl = context.origin.asParsedURL();
     var label = parsedUrl ? parsedUrl.lastPathComponentWithFragment() : context.name;
     if (version)
       context.setLabel(label + ' #' + version.id + ' (' + version.status + ')');
     else
       context.setLabel(label);
   }
 };