Keep track of per-origin security details in the Security panel.

Source/devtools/front_end/security/SecurityModel.js

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /**
  * @constructor
  * @extends {WebInspector.SDKModel}
  * @param {!WebInspector.Target} target
  */
 WebInspector.SecurityModel = function(target)
 {
     WebInspector.SDKModel.call(this, WebInspector.SecurityModel, target);
     this._dispatcher = new WebInspector.SecurityDispatcher(this);
     this._securityAgent = target.securityAgent();
+    this._networkManager = target.networkManager;
     target.registerSecurityDispatcher(this._dispatcher);
+    this._networkManager.addEventListener(WebInspector.NetworkManager.EventTypes.ReceivedResponseSecurity, this._onReceivedResponseSecurity, this);

[pfeldman, 2015/08/18 18:35:08]

It is not typical for models to listen to each other's events, it is better to
perform the binding on the UI level should the need be.

[lgarron, 2015/08/18 19:37:06]

Thanks, that's very useful to know.

In that case, I presume SecurityModel and NetworkManager should both dispatch
events to the SecurityPanel, which decides how to handle them. The other panels
don't seem to have a centralized model for handling that, so presume I don't
need to?

     this._securityAgent.enable();
 
+    // TODO(lgarron): Reset upon page reload.
+    this.origins = {

[lgarron, 2015/08/18 02:47:22]

My plan is for SecurityModel as a middleman to keep track of security properties
of an origin (e.g. security state, connection details), and calculate+route the
appropriate changes to the Security panel so that the Security panel can focus
on UI.

+
+    };
+
     this._securityState = SecurityAgent.SecurityState.Unknown;
 }
 
 WebInspector.SecurityModel.EventTypes = {
-    SecurityStateChanged: "SecurityStateChanged"
+    SecurityStateChanged: "SecurityStateChanged",
+    OriginSecurityChanged: "OriginSecurityChanged"
 }
 
 WebInspector.SecurityModel.prototype = {
     /**
      * @return {!SecurityAgent.SecurityState} securityState
      */
     securityState: function()
     {
         return /** @type {!SecurityAgent.SecurityState} */ (this._securityState);
     },
 
+    /**
+     * @param {!WebInspector.Event} event
+     */
+    _onReceivedResponseSecurity: function(event)
+    {
+        var response = event.data;
+        var origin = response.origin;
+        var securityState = response.securityState;
+        if (origin in this.origins) {
+            if (this._securityStateDecreased(this.origins[origin].securityState), securityState) {
+                this.origins[origin].securityState = securityState;
+
+                var originEventData = {};
+                originEventData.origin = origin;
+                originEventData.securityState = securityState;
+                if (response.securityDetails) {
+                    originEventData.securityDetails = response.securityDetails;
+                    originEventData.certificateDetails = response.certificateDetails;
+                }
+                this.dispatchEventToListeners(WebInspector.SecurityModel.EventTypes.OriginSecurityChanged, originEventData);
+            }
+        }
+        else {

[dgozman, 2015/08/18 18:41:49]

nit: else on the same line as }

+            this.origins[origin] = {};
+            this.origins[origin].securityState = securityState;
+        }
+    },
+
+
+    /**
+     * @param {!SecurityAgent.SecurityState} oldState
+     * @param {!SecurityAgent.SecurityState} newState
+     * @return {!bool}
+     */
+    _securityStateDecreased: function(oldState, newState) {

[dgozman, 2015/08/18 18:41:49]

nit: { on next line

+        // TODO(lgarron): this doesn't take active mixed content into account.
+        var ordering = ["unknown", "insecure", "http", "warning", "secure"];
+        return ordering.indexOf(newState) < ordering.indexOf(oldState);
+    },
+
     __proto__: WebInspector.SDKModel.prototype
 }
 
 /**
  * @param {!WebInspector.Target} target
  * @return {?WebInspector.SecurityModel}
  */
 WebInspector.SecurityModel.fromTarget = function(target)
 {
     var model = /** @type {?WebInspector.SecurityModel} */ (target.model(WebInspector.SecurityModel));
@@ skipping 16 matching lines @@
      * @override
      * @param {!SecurityAgent.SecurityState} securityState
      * @param {!Array<!SecurityAgent.SecurityStateExplanation>=} explanations
      */
     securityStateChanged: function(securityState, explanations)
     {
         var data = {"securityState": securityState, "explanations": explanations || []};
         this._model.dispatchEventToListeners(WebInspector.SecurityModel.EventTypes.SecurityStateChanged, data);
     }
 }