Distinguish STS observation times from PKP observation times.

chrome/test/data/webui/net_internals/hsts_view.js

 // Copyright (c) 2012 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.
 
 // Include test fixture.
 GEN_INCLUDE(['net_internals_test.js']);
 
 // Anonymous namespace
 (function() {
 
@@ skipping 22 matching lines @@
 /**
  * A Task that waits for the results of an HSTS query.  Once the results are
  * received, checks them before completing.  Does not initiate the query.
  * @param {string} domain The domain expected in the returned results.
  * @param {bool} stsSubdomains Whether or not the stsSubdomains flag is expected
  *     to be set in the returned results.  Ignored on error and not found
  *     results.
  * @param {bool} pkpSubdomains Whether or not the pkpSubdomains flag is expected
  *     to be set in the returned results.  Ignored on error and not found
  *     results.
+ * @param {number} stsObserved The time the STS policy was observed.
+ * @param {number} pkpObserved The time the PKP policy was observed.
  * @param {string} publicKeyHashes Expected public key hashes.  Ignored on error
  *     error and not found results.
  * @param {QueryResultType} queryResultType The expected result type of the
  *     results of the query.
  * @extends {NetInternalsTest.Task}
  */
 function CheckQueryResultTask(domain, stsSubdomains, pkpSubdomains,
-                              publicKeyHashes, queryResultType) {
+                              stsObserved, pkpObserved, publicKeyHashes,
+                              queryResultType) {
   this.domain_ = domain;
   this.stsSubdomains_ = stsSubdomains;
   this.pkpSubdomains_ = pkpSubdomains;
+  this.stsObserved_ = stsObserved;
+  this.pkpObserved_ = pkpObserved;
   this.publicKeyHashes_ = publicKeyHashes;
   this.queryResultType_ = queryResultType;
   NetInternalsTest.Task.call(this);
 }
 
 CheckQueryResultTask.prototype = {
   __proto__: NetInternalsTest.Task.prototype,
 
   /**
    * Starts watching for the query results.
@@ skipping 48 matching lines @@
   },
 
   /**
    * Checks successful results.
    * @param {object} result Results from the query.
    */
   checkSuccess_: function(result) {
     expectEquals(QueryResultType.SUCCESS, this.queryResultType_);
     expectEquals(this.stsSubdomains_, result.sts_subdomains);
     expectEquals(this.pkpSubdomains_, result.pkp_subdomains);
+    expectEquals(this.stsObserved_, result.sts_observed);
+    expectEquals(this.pkpObserved_, result.pkp_observed);
 
     // |public_key_hashes| is an old synonym for what is now
     // |preloaded_spki_hashes|, which in turn is a legacy synonym for
     // |static_spki_hashes|. Look for all three, and also for
     // |dynamic_spki_hashes|.
     if (typeof result.public_key_hashes === 'undefined')
       result.public_key_hashes = '';
     if (typeof result.preloaded_spki_hashes === 'undefined')
       result.preloaded_spki_hashes = '';
     if (typeof result.static_spki_hashes === 'undefined')
@@ skipping 23 matching lines @@
  * A Task to try and add an HSTS domain via the HTML form.  The task will wait
  * until the results from the automatically sent query have been received, and
  * then checks them against the expected values.
  * @param {string} domain The domain to send and expected to be returned.
  * @param {bool} stsSubdomains Whether the HSTS subdomain checkbox should be
  *     selected. Also the corresponding expected return value, in the success
  *     case.
  * @param {bool} pkpSubdomains Whether the pinning subdomain checkbox should be
  *     selected. Also the corresponding expected return value, in the success
  *     case.
+ * @param {number} stsObserved The time the STS policy was observed.
+ * @param {number} pkpObserved The time the PKP policy was observed.
  * @param {string} publicKeyHashes Public key hash to send.  Also the
  *     corresponding expected return value, on success.  When this is the string
  *     INVALID_HASH, an empty string is expected to be received instead.
  * @param {QueryResultType} queryResultType Expected result type.
  * @extends {CheckQueryResultTask}
  */
 function AddTask(domain, stsSubdomains, pkpSubdomains, publicKeyHashes,
-                 queryResultType) {
+                 stsObserved, pkpObserved, queryResultType) {
   this.requestedPublicKeyHashes_ = publicKeyHashes;
   if (publicKeyHashes == INVALID_HASH)
     publicKeyHashes = '';
   CheckQueryResultTask.call(this, domain, stsSubdomains, pkpSubdomains,
-                            publicKeyHashes, queryResultType);
+                            stsObserved, pkpObserved, publicKeyHashes,
+                            queryResultType);
 }
 
 AddTask.prototype = {
   __proto__: CheckQueryResultTask.prototype,
 
   /**
    * Fills out the add form, simulates a click to submit it, and starts
    * listening for the results of the query that is automatically submitted.
    */
   start: function() {
     $(HSTSView.ADD_INPUT_ID).value = this.domain_;
     $(HSTSView.ADD_STS_CHECK_ID).checked = this.stsSubdomains_;
     $(HSTSView.ADD_PKP_CHECK_ID).checked = this.pkpSubdomains_;
     $(HSTSView.ADD_PINS_ID).value = this.requestedPublicKeyHashes_;
     $(HSTSView.ADD_SUBMIT_ID).click();
     CheckQueryResultTask.prototype.start.call(this);
   }
 };
 
 /**
  * A Task to query a domain and wait for the results.  Parameters mirror those
  * of CheckQueryResultTask, except |domain| is also the name of the domain to
  * query.
  * @extends {CheckQueryResultTask}
  */
-function QueryTask(domain, stsSubdomains, pkpSubdomains, publicKeyHashes,
-                   queryResultType) {
+function QueryTask(domain, stsSubdomains, pkpSubdomains, stsObserved,
+                   pkpObserved, publicKeyHashes, queryResultType) {
   CheckQueryResultTask.call(this, domain, stsSubdomains, pkpSubdomains,
-                            publicKeyHashes, queryResultType);
+                            stsObserved, pkpObserved, publicKeyHashes,
+                            queryResultType);
 }
 
 QueryTask.prototype = {
   __proto__: CheckQueryResultTask.prototype,
 
   /**
    * Fills out the query form, simulates a click to submit it, and starts
    * listening for the results.
    */
   start: function() {
@@ skipping 151 matching lines @@
                                   QueryResultType.SUCCESS));
   taskQueue.addTask(new DeleteTask('somewhere.com', QueryResultType.NOT_FOUND));
   taskQueue.addTask(new QueryTask('somewhereelse.com', true, true, '',
                                   QueryResultType.SUCCESS));
   taskQueue.addTask(new DeleteTask('somewhereelse.com',
                                    QueryResultType.NOT_FOUND));
   taskQueue.run(true);
 });
 
 })();  // Anonymous namespace