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);
+    expectLE(this.stsObserved_, result.sts_observed);
+    expectLE(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() {
     CheckQueryResultTask.prototype.start.call(this);
     $(HSTSView.QUERY_INPUT_ID).value = this.domain_;
     $(HSTSView.QUERY_SUBMIT_ID).click();
   }
 };
 
 /**
  * Task that deletes a single domain, then queries the deleted domain to make
  * sure it's gone.
  * @param {string} domain The domain to delete.
  * @param {QueryResultType} queryResultType The result of the query.  Can be
  *     QueryResultType.ERROR or QueryResultType.NOT_FOUND.
  * @extends {QueryTask}
  */
 function DeleteTask(domain, queryResultType) {
   expectNotEquals(queryResultType, QueryResultType.SUCCESS);
   this.domain_ = domain;
-  QueryTask.call(this, domain, false, false, '', queryResultType);
+  QueryTask.call(this, domain, false, false, '', 0, 0, queryResultType);
 }
 
 DeleteTask.prototype = {
   __proto__: QueryTask.prototype,
 
   /**
    * Fills out the delete form and simulates a click to submit it.  Then sends
    * a query.
    */
   start: function() {
     $(HSTSView.DELETE_INPUT_ID).value = this.domain_;
     $(HSTSView.DELETE_SUBMIT_ID).click();
     QueryTask.prototype.start.call(this);
   }
 };
 
 /**
  * Checks that querying a domain that was never added fails.
  */
 TEST_F('NetInternalsTest', 'netInternalsHSTSViewQueryNotFound', function() {
   NetInternalsTest.switchToView('hsts');
   taskQueue = new NetInternalsTest.TaskQueue(true);
-  taskQueue.addTask(new QueryTask('somewhere.com', false, false, '',
+  var now = new Date().getTime() / 1000.0;
+  taskQueue.addTask(new QueryTask('somewhere.com', false, false, now, now, '',
                                   QueryResultType.NOT_FOUND));
   taskQueue.run();
 });
 
 /**
  * Checks that querying a domain with an invalid name returns an error.
  */
 TEST_F('NetInternalsTest', 'netInternalsHSTSViewQueryError', function() {
   NetInternalsTest.switchToView('hsts');
   taskQueue = new NetInternalsTest.TaskQueue(true);
-  taskQueue.addTask(new QueryTask('\u3024', false, false, '',
+  var now = new Date().getTime() / 1000.0;
+  taskQueue.addTask(new QueryTask('\u3024', false, false, now, now, '',
                                   QueryResultType.ERROR));
   taskQueue.run();
 });
 
 /**
  * Deletes a domain that was never added.
  */
 TEST_F('NetInternalsTest', 'netInternalsHSTSViewDeleteNotFound', function() {
   NetInternalsTest.switchToView('hsts');
   taskQueue = new NetInternalsTest.TaskQueue(true);
@@ skipping 10 matching lines @@
   taskQueue.addTask(new DeleteTask('\u3024', QueryResultType.ERROR));
   taskQueue.run();
 });
 
 /**
  * Adds a domain and then deletes it.
  */
 TEST_F('NetInternalsTest', 'netInternalsHSTSViewAddDelete', function() {
   NetInternalsTest.switchToView('hsts');
   taskQueue = new NetInternalsTest.TaskQueue(true);
+  var now = new Date().getTime() / 1000.0;
   taskQueue.addTask(new AddTask('somewhere.com', false, false, VALID_HASH,
-                                QueryResultType.SUCCESS));
+                                now, now, QueryResultType.SUCCESS));
   taskQueue.addTask(new DeleteTask('somewhere.com', QueryResultType.NOT_FOUND));
   taskQueue.run();
 });
 
 /**
  * Tries to add a domain with an invalid name.
  */
 TEST_F('NetInternalsTest', 'netInternalsHSTSViewAddFail', function() {
   NetInternalsTest.switchToView('hsts');
   taskQueue = new NetInternalsTest.TaskQueue(true);
+  var now = new Date().getTime() / 1000.0;
   taskQueue.addTask(new AddTask('0123456789012345678901234567890' +
                                 '012345678901234567890123456789012345',
-                                false, false, '', QueryResultType.NOT_FOUND));
+                                false, false, '', now, now,
+                                QueryResultType.NOT_FOUND));
   taskQueue.run();
 });
 
 /**
  * Tries to add a domain with a name that errors out on lookup due to having
  * non-ASCII characters in it.
  */
 TEST_F('NetInternalsTest', 'netInternalsHSTSViewAddError', function() {
   NetInternalsTest.switchToView('hsts');
   taskQueue = new NetInternalsTest.TaskQueue(true);
-  taskQueue.addTask(new AddTask('\u3024', false, false, '',
+  var now = new Date().getTime() / 1000.0;
+  taskQueue.addTask(new AddTask('\u3024', false, false, '', now, now,
                                 QueryResultType.ERROR));
   taskQueue.run();
 });
 
 /**
  * Adds a domain with an invalid hash.
  */
 TEST_F('NetInternalsTest', 'netInternalsHSTSViewAddInvalidHash', function() {
   NetInternalsTest.switchToView('hsts');
   taskQueue = new NetInternalsTest.TaskQueue(true);
+  var now = new Date().getTime() / 1000.0;
   taskQueue.addTask(new AddTask('somewhere.com', true, true, INVALID_HASH,
-                                QueryResultType.SUCCESS));
+                                now, now, QueryResultType.SUCCESS));
   taskQueue.addTask(new DeleteTask('somewhere.com', QueryResultType.NOT_FOUND));
   taskQueue.run();
 });
 
 /**
  * Adds the same domain twice in a row, modifying some values the second time.
  */
 TEST_F('NetInternalsTest', 'netInternalsHSTSViewAddOverwrite', function() {
   NetInternalsTest.switchToView('hsts');
   taskQueue = new NetInternalsTest.TaskQueue(true);
+  var now = new Date().getTime() / 1000.0;
   taskQueue.addTask(new AddTask('somewhere.com', true, true, VALID_HASH,
-                                QueryResultType.SUCCESS));
+                                now, now, QueryResultType.SUCCESS));
   taskQueue.addTask(new AddTask('somewhere.com', false, false, '',
-                                QueryResultType.SUCCESS));
+                                now, now, QueryResultType.SUCCESS));
   taskQueue.addTask(new DeleteTask('somewhere.com', QueryResultType.NOT_FOUND));
   taskQueue.run();
 });
 
 /**
  * Adds two different domains and then deletes them.
  */
 TEST_F('NetInternalsTest', 'netInternalsHSTSViewAddTwice', function() {
   NetInternalsTest.switchToView('hsts');
   taskQueue = new NetInternalsTest.TaskQueue(true);
+  var now = new Date().getTime() / 1000.0;
   taskQueue.addTask(new AddTask('somewhere.com', false, false, VALID_HASH,
-                                QueryResultType.SUCCESS));
-  taskQueue.addTask(new QueryTask('somewhereelse.com', false, false, '',
-                                  QueryResultType.NOT_FOUND));
+                                now, now, QueryResultType.SUCCESS));
+  taskQueue.addTask(new QueryTask('somewhereelse.com', false, false, now, now,
+                                  '', QueryResultType.NOT_FOUND));
   taskQueue.addTask(new AddTask('somewhereelse.com', true, true, '',
-                                QueryResultType.SUCCESS));
-  taskQueue.addTask(new QueryTask('somewhere.com', false, false, VALID_HASH,
-                                  QueryResultType.SUCCESS));
+                                now, now, QueryResultType.SUCCESS));
+  taskQueue.addTask(new QueryTask('somewhere.com', false, false, now, now,
+                                  VALID_HASH, QueryResultType.SUCCESS));
   taskQueue.addTask(new DeleteTask('somewhere.com', QueryResultType.NOT_FOUND));
-  taskQueue.addTask(new QueryTask('somewhereelse.com', true, true, '',
+  taskQueue.addTask(new QueryTask('somewhereelse.com', true, true, now, now, '',
                                   QueryResultType.SUCCESS));
   taskQueue.addTask(new DeleteTask('somewhereelse.com',
                                    QueryResultType.NOT_FOUND));
   taskQueue.run(true);
 });
 
 })();  // Anonymous namespace