Update from https://crrev.com/304121

net/http/transport_security_state.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 "net/http/transport_security_state.h"
 
 #if defined(USE_OPENSSL)
 #include <openssl/ecdsa.h>
 #include <openssl/ssl.h>
 #else  // !defined(USE_OPENSSL)
@@ skipping 397 matching lines @@
 #include "net/http/transport_security_state_static.h"
 
 // PreloadResult is the result of resolving a specific name in the preloaded
 // data.
 struct PreloadResult {
   uint32 pinset_id;
   uint32 domain_id;
   // hostname_offset contains the number of bytes from the start of the given
   // hostname where the name of the matching entry starts.
   size_t hostname_offset;
-  bool include_subdomains;
+  bool sts_include_subdomains;
+  bool pkp_include_subdomains;
   bool force_https;
   bool has_pins;
 };
 
 // DecodeHSTSPreloadRaw resolves |hostname| in the preloaded data. It returns
 // false on internal error and true otherwise. After a successful return,
 // |*out_found| is true iff a relevant entry has been found. If so, |*out|
 // contains the details.
 //
 // Don't call this function, call DecodeHSTSPreload, below.
@@ skipping 73 matching lines @@
       if (!huffman.Decode(&reader, &c)) {
         return false;
       }
       if (c == kEndOfTable) {
         // No exact match.
         return true;
       }
 
       if (c == kEndOfString) {
         PreloadResult tmp;
-        if (!reader.Next(&tmp.include_subdomains) ||
+        if (!reader.Next(&tmp.sts_include_subdomains) ||
             !reader.Next(&tmp.force_https) ||
             !reader.Next(&tmp.has_pins)) {
           return false;
         }
 
+        tmp.pkp_include_subdomains = tmp.sts_include_subdomains;
+
         if (tmp.has_pins) {
           if (!reader.Read(4, &tmp.pinset_id) ||
-              !reader.Read(9, &tmp.domain_id)) {
+              !reader.Read(9, &tmp.domain_id) ||
+              (!tmp.sts_include_subdomains &&
+               !reader.Next(&tmp.pkp_include_subdomains))) {
             return false;
           }
         }
 
         tmp.hostname_offset = hostname_offset;
 
         if (hostname_offset == 0 || hostname[hostname_offset - 1] == '.') {
-          *out_found = tmp.include_subdomains;
+          *out_found =
+              tmp.sts_include_subdomains || tmp.pkp_include_subdomains;
           *out = tmp;
-        }
 
-        if (hostname_offset == 0) {
-          *out_found = true;
-          return true;
+          if (hostname_offset > 0) {
+            out->force_https &= tmp.sts_include_subdomains;
+          } else {
+            *out_found = true;
+            return true;
+          }
         }
 
         continue;
       }
 
       // The entries in a dispatch table are in order thus we can tell if there
       // will be no match if the current character past the one that we want.
       if (hostname_offset == 0 || hostname[hostname_offset-1] < c) {
         return true;
       }
@@ skipping 216 matching lines @@
   out->pkp.include_subdomains = false;
 
   if (!IsBuildTimely())
     return false;
 
   PreloadResult result;
   if (!DecodeHSTSPreload(host, &result))
     return false;
 
   out->domain = host.substr(result.hostname_offset);
-  out->sts.include_subdomains = result.include_subdomains;
+  out->sts.include_subdomains = result.sts_include_subdomains;
   out->sts.last_observed = base::GetBuildTime();
   out->sts.upgrade_mode =
       TransportSecurityState::DomainState::MODE_DEFAULT;
   if (result.force_https) {
     out->sts.upgrade_mode =
         TransportSecurityState::DomainState::MODE_FORCE_HTTPS;
   }
 
   if (enable_static_pins_ && result.has_pins) {
-    out->pkp.include_subdomains = result.include_subdomains;
+    out->pkp.include_subdomains = result.pkp_include_subdomains;
     out->pkp.last_observed = base::GetBuildTime();
 
     if (result.pinset_id >= arraysize(kPinsets))
       return false;
     const Pinset *pinset = &kPinsets[result.pinset_id];
 
     if (pinset->accepted_pins) {
       const char* const* sha1_hash = pinset->accepted_pins;
       while (*sha1_hash) {
         AddHash(*sha1_hash, &out->pkp.spki_hashes);
@@ skipping 116 matching lines @@
   return pkp.spki_hashes.size() > 0 || pkp.bad_spki_hashes.size() > 0;
 }
 
 TransportSecurityState::DomainState::PKPState::PKPState() {
 }
 
 TransportSecurityState::DomainState::PKPState::~PKPState() {
 }
 
 }  // namespace