Improve TransportSecurityState data storage.

net/http/http_security_headers.cc

 // 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 "base/base64.h"
 #include "base/basictypes.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/strings/string_tokenizer.h"
 #include "net/http/http_security_headers.h"
@@ skipping 146 matching lines @@
 // 3.  Directive names are case-insensitive.
 //
 // 4.  UAs MUST ignore any STS header fields containing directives, or
 //     other header field value data, that does not conform to the
 //     syntax defined in this specification.
 //
 // 5.  If an STS header field contains directive(s) not recognized by
 //     the UA, the UA MUST ignore the unrecognized directives and if the
 //     STS header field otherwise satisfies the above requirements (1
 //     through 4), the UA MUST process the recognized directives.
-bool ParseHSTSHeader(const base::Time& now, const std::string& value,
-                     base::Time* expiry,         // OUT
+bool ParseHSTSHeader(const std::string& value,
+                     base::TimeDelta* max_age,    // OUT
                      bool* include_subdomains) {  // OUT
   uint32 max_age_candidate = 0;
   bool include_subdomains_candidate = false;
 
   // We must see max-age exactly once.
   int max_age_observed = 0;
   // We must see includeSubdomains exactly 0 or 1 times.
   int include_subdomains_observed = 0;
 
   enum ParserState {
@@ skipping 70 matching lines @@
   // We've consumed all the input.  Let's see what state we ended up in.
   if (max_age_observed != 1 ||
       (include_subdomains_observed != 0 && include_subdomains_observed != 1)) {
     return false;
   }
 
   switch (state) {
     case AFTER_MAX_AGE:
     case AFTER_INCLUDE_SUBDOMAINS:
     case AFTER_UNKNOWN_LABEL:
-      *expiry = now + base::TimeDelta::FromSeconds(max_age_candidate);
+      *max_age = base::TimeDelta::FromSeconds(max_age_candidate);
       *include_subdomains = include_subdomains_candidate;
       return true;
     case START:
     case DIRECTIVE_END:
     case AFTER_MAX_AGE_LABEL:
     case AFTER_MAX_AGE_EQUALS:
       return false;
     default:
       NOTREACHED();
       return false;
   }
 }
 
 // "Public-Key-Pins" ":"
 //     "max-age" "=" delta-seconds ";"
 //     "pin-" algo "=" base64 [ ";" ... ]
-bool ParseHPKPHeader(const base::Time& now,
-                     const std::string& value,
+bool ParseHPKPHeader(const std::string& value,
                      const HashValueVector& chain_hashes,
-                     base::Time* expiry,
+                     base::TimeDelta* max_age,
                      HashValueVector* hashes) {
   bool parsed_max_age = false;
   uint32 max_age_candidate = 0;
   HashValueVector pins;
 
   std::string source = value;
 
   while (!source.empty()) {
     StringPair semicolon = Split(source, ';');
     semicolon.first = Strip(semicolon.first);
@@ skipping 21 matching lines @@
 
     source = semicolon.second;
   }
 
   if (!parsed_max_age)
     return false;
 
   if (!IsPinListValid(pins, chain_hashes))
     return false;
 
-  *expiry = now + base::TimeDelta::FromSeconds(max_age_candidate);
+  *max_age = base::TimeDelta::FromSeconds(max_age_candidate);
   for (HashValueVector::const_iterator i = pins.begin();
        i != pins.end(); ++i) {
     hashes->push_back(*i);
   }
 
   return true;
 }
 
 }  // namespace net