DevTools: simplify Service Workers panel UI, remove non-actionable data.

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 36 matching lines @@
     this._forceUpdateSetting = WebInspector.settings.createSetting("serviceWorkerUpdateOnReload", false);
     if (this._forceUpdateSetting.get())
         this._forceUpdateSettingChanged();
     this._forceUpdateSetting.addChangeListener(this._forceUpdateSettingChanged, this);
     WebInspector.targetManager.addModelListener(WebInspector.RuntimeModel, WebInspector.RuntimeModel.Events.ExecutionContextCreated, this._executionContextCreated, this);
 }
 
 WebInspector.ServiceWorkerManager.Events = {
     WorkersUpdated: "WorkersUpdated",
     RegistrationUpdated: "RegistrationUpdated",
+    RegistrationErrorAdded: "RegistrationErrorAdded",
     RegistrationDeleted: "RegistrationDeleted"
 }
 
 WebInspector.ServiceWorkerManager.prototype = {
     enable: function()
     {
         if (this._enabled)
             return;
         this._enabled = true;
 
@@ skipping 18 matching lines @@
     /**
      * @return {!Iterable.<!WebInspector.ServiceWorker>}
      */
     workers: function()
     {
         return this._workers.values();
     },
 
     /**
      * @param {string} versionId
-     * @return {boolean}
+     * @return {?WebInspector.Target}
      */
-    hasWorkerWithVersionId: function(versionId)
+    targetForVersionId: function(versionId)
     {
         for (var pair of this._workers) {
             if (pair[1]._versionId === versionId)
-                return true;
+                return pair[1]._target;
         }
-        return false;
+        return null;
     },
 
     /**
      * @return {boolean}
      */
     hasWorkers: function()
     {
         return !!this._workers.size;
     },
 
@@ skipping 80 matching lines @@
 
     /**
      * @param {string} scope
      */
     startWorker: function(scope)
     {
         this._agent.startWorker(scope);
     },
 
     /**
+     * @param {string} scope
+     */
+    skipWaiting: function(scope)
+    {
+        this._agent.skipWaiting(scope);
+    },
+
+    /**
      * @param {string} versionId
      */
     stopWorker: function(versionId)
     {
         this._agent.stopWorker(versionId);
     },
 
     /**
      * @param {string} versionId
      */
@@ skipping 124 matching lines @@
         for (var worker of this._workers.valuesArray()) {
             var status = versionById.get(worker.versionId());
             if (status)
                 worker.setStatus(status);
         }
     },
 
     /**
      * @param {!ServiceWorkerAgent.ServiceWorkerErrorMessage} payload
      */
-     _workerErrorReported: function(payload)
+    _workerErrorReported: function(payload)
     {
         var registration = this._registrations.get(payload.registrationId);
         if (!registration)
             return;
-        registration._addError(payload);
-        this.dispatchEventToListeners(WebInspector.ServiceWorkerManager.Events.RegistrationUpdated, registration);
+        registration.errors.push(payload);
+        this.dispatchEventToListeners(WebInspector.ServiceWorkerManager.Events.RegistrationErrorAdded, { registration: registration, error: payload });
     },
 
     /**
      * @param {!WebInspector.Event} event
      */
     _mainFrameNavigated: function(event)
     {
         // Attach to the new worker set.
     },
 
@@ skipping 111 matching lines @@
     },
 
     /**
      * @param {!WebInspector.ExecutionContext} context
      */
     _setContextLabelFor: function(context)
     {
         var parsedUrl = context.origin.asParsedURL();
         var label = parsedUrl ? parsedUrl.lastPathComponentWithFragment() : context.name;
         if (this._status)
-            context.setLabel(label + " (" + this._status + ")");
+            context.setLabel(label + " #" + this._versionId + " (" + this._status + ")");
         else
             context.setLabel(label);
     },
 
     _closeConnection: function()
     {
         this._connection._close();
         delete this._connection;
     }
 }
@@ skipping 124 matching lines @@
      * @return {boolean}
      */
     isFrame: function()
     {
         return this.type == "frame";
     },
 }
 
 /**
  * @constructor
- * @param {!ServiceWorkerAgent.ServiceWorkerErrorMessage} payload
- */
-WebInspector.ServiceWorkerErrorMessage = function(payload)
-{
-    this.errorMessage = payload.errorMessage;
-    this.sourceURL = payload.sourceURL;
-    this.lineNumber = payload.lineNumber;
-    this.columnNumber = payload.columnNumber;
-}
-
-/**
- * @constructor
  * @param {!WebInspector.ServiceWorkerRegistration} registration
  * @param {!ServiceWorkerAgent.ServiceWorkerVersion} payload
  */
 WebInspector.ServiceWorkerVersion = function(registration, payload)
 {
     this.registration = registration;
     this._update(payload);
-    /** @type {!Array<!WebInspector.ServiceWorkerErrorMessage>} */
-    this.errorMessages = [];
 }
 
 /**
  * @enum {string}
  */
 WebInspector.ServiceWorkerVersion.Modes = {
     Installing: "installing",
     Waiting: "waiting",
     Active: "active",
     Redundant: "redundant"
 }
 
 WebInspector.ServiceWorkerVersion.prototype = {
     /**
      * @param {!ServiceWorkerAgent.ServiceWorkerVersion} payload
      */
     _update: function(payload)
     {
         this.id = payload.versionId;
         this.scriptURL = payload.scriptURL;
+        this.securityOrigin = payload.scriptURL.asParsedURL().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 = [];
+        for (var i = 0; i < payload.controlledClients.length; ++i)
             this.controlledClients.push(payload.controlledClients[i]);
-        }
     },
 
     /**
      * @return {boolean}
      */
     isStartable: function()
     {
         return !this.registration.isDeleted && this.isActivated() && this.isStopped();
     },
 
@@ skipping 90 matching lines @@
      */
     mode: function()
     {
         if (this.isNew() || this.isInstalling())
             return WebInspector.ServiceWorkerVersion.Modes.Installing;
         else if (this.isInstalled())
             return WebInspector.ServiceWorkerVersion.Modes.Waiting;
         else if (this.isActivating() || this.isActivated())
             return WebInspector.ServiceWorkerVersion.Modes.Active;
         return WebInspector.ServiceWorkerVersion.Modes.Redundant;
-    },
-
-    /**
-     * @param {!ServiceWorkerAgent.ServiceWorkerErrorMessage} payload
-     */
-    _addError: function(payload)
-    {
-        this.errorMessages.push(new WebInspector.ServiceWorkerErrorMessage(payload));
     }
 }
 
 /**
 * @constructor
 * @param {!ServiceWorkerAgent.ServiceWorkerRegistration} payload
 */
 WebInspector.ServiceWorkerRegistration = function(payload)
 {
    this._update(payload);
    /** @type {!Map.<string, !WebInspector.ServiceWorkerVersion>} */
    this.versions = new Map();
    this._deleting = false;
+   /** @type {!Array<!ServiceWorkerAgent.ServiceWorkerErrorMessage>} */
+   this.errors = [];
 }
 
 WebInspector.ServiceWorkerRegistration.prototype = {
     /**
      * @param {!ServiceWorkerAgent.ServiceWorkerRegistration} payload
      */
     _update: function(payload)
     {
+        this._fingerprint = Symbol("fingerprint");
         this.id = payload.registrationId;
         this.scopeURL = payload.scopeURL;
+        this.securityOrigin = payload.scopeURL.asParsedURL().securityOrigin();
         this.isDeleted = payload.isDeleted;
         this.forceUpdateOnPageLoad = payload.forceUpdateOnPageLoad;
     },
 
     /**
+     * @return {symbol}
+     */
+    fingerprint: function()
+    {
+        return this._fingerprint;
+    },
+
+    /**
+     * @return {!Map<string, !WebInspector.ServiceWorkerVersion>}
+     */
+    versionsByMode: function()
+    {
+        /** @type {!Map<string, !WebInspector.ServiceWorkerVersion>} */
+        var result = new Map();
+        for (var version of this.versions.values())
+            result.set(version.mode(), version);
+        return result;
+    },
+
+    /**
      * @param {!ServiceWorkerAgent.ServiceWorkerVersion} payload
      * @return {!WebInspector.ServiceWorkerVersion}
      */
     _updateVersion: function(payload)
     {
+        this._fingerprint = Symbol("fingerprint");
         var version = this.versions.get(payload.versionId);
         if (!version) {
             version = new WebInspector.ServiceWorkerVersion(this, payload);
             this.versions.set(payload.versionId, version);
             return version;
         }
         version._update(payload);
         return version;
     },
 
     /**
-     * @param {!ServiceWorkerAgent.ServiceWorkerErrorMessage} payload
-     */
-    _addError: function(payload)
-    {
-        var version = this.versions.get(payload.versionId);
-        if (version)
-            version._addError(payload);
-    },
-
-    /**
      * @return {boolean}
      */
     _isRedundant: function()
     {
         for (var version of this.versions.values()) {
             if (!version.isStoppedAndRedundant())
                 return false;
         }
         return true;
     },
 
     /**
      * @return {boolean}
      */
-    _hasErrorLog: function()
-    {
-        for (var version of this.versions.values()) {
-            if (version.errorMessages.length)
-                return true;
-        }
-        return false;
-    },
-
-    /**
-     * @return {boolean}
-     */
     _shouldBeRemoved: function()
     {
-        return this._isRedundant() && (!this._hasErrorLog() || this._deleting);
+        return this._isRedundant() && (!this.errors.length || this._deleting);
+    },
+
+    clearErrors: function()
+    {
+        this._fingerprint = Symbol("fingerprint");
+        this.errors = [];
     }
 }