Expose when PKP is bypassed in SSLInfo.

net/http/http_response_info.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/http_response_info.h"
 
 #include "base/logging.h"
 #include "base/pickle.h"
 #include "base/time/time.h"
 #include "net/base/auth.h"
@@ skipping 78 matching lines @@
   RESPONSE_INFO_USE_HTTP_AUTHENTICATION = 1 << 19,
 
   // This bit is set if ssl_info has SCTs.
   RESPONSE_INFO_HAS_SIGNED_CERTIFICATE_TIMESTAMPS = 1 << 20,
 
   RESPONSE_INFO_UNUSED_SINCE_PREFETCH = 1 << 21,
 
   // This bit is set if the response has a key-exchange-info field at the end.
   RESPONSE_INFO_HAS_KEY_EXCHANGE_INFO = 1 << 22,
 
+  // This bit is set if ssl_info recorded that PKP was bypassed due to a local
+  // trust anchor

[estark, 2016/06/07 04:10:43]

nit: period at the end

[dadrian, 2016/06/07 17:48:22]

Done.

+  RESPONSE_INFO_PKP_BYPASSED = 1 << 23,
+
   // TODO(darin): Add other bits to indicate alternate request methods.
   // For now, we don't support storing those.
 };
 
 HttpResponseInfo::HttpResponseInfo()
     : was_cached(false),
       server_data_unavailable(false),
       network_accessed(false),
       was_fetched_via_spdy(false),
       was_npn_negotiated(false),
@@ skipping 180 matching lines @@
   was_npn_negotiated = (flags & RESPONSE_INFO_WAS_NPN) != 0;
 
   was_fetched_via_proxy = (flags & RESPONSE_INFO_WAS_PROXY) != 0;
 
   *response_truncated = (flags & RESPONSE_INFO_TRUNCATED) != 0;
 
   did_use_http_auth = (flags & RESPONSE_INFO_USE_HTTP_AUTHENTICATION) != 0;
 
   unused_since_prefetch = (flags & RESPONSE_INFO_UNUSED_SINCE_PREFETCH) != 0;
 
+  ssl_info.pkp_bypassed = (flags & RESPONSE_INFO_PKP_BYPASSED);

[estark, 2016/06/07 04:10:43]

nit: != 0
(for consistency with the lines above, plus I think some compiler will complain
without this... maybe?)

[dadrian, 2016/06/07 17:48:22]

Wow, I totally missed the `!= 0` on the other lines.

Done.

+
   return true;
 }
 
 void HttpResponseInfo::Persist(base::Pickle* pickle,
                                bool skip_transient_headers,
                                bool response_truncated) const {
   int flags = RESPONSE_INFO_VERSION;
   if (ssl_info.is_valid()) {
     flags |= RESPONSE_INFO_HAS_CERT;
     flags |= RESPONSE_INFO_HAS_CERT_STATUS;
@@ skipping 17 matching lines @@
   if (was_fetched_via_proxy)
     flags |= RESPONSE_INFO_WAS_PROXY;
   if (connection_info != CONNECTION_INFO_UNKNOWN)
     flags |= RESPONSE_INFO_HAS_CONNECTION_INFO;
   if (did_use_http_auth)
     flags |= RESPONSE_INFO_USE_HTTP_AUTHENTICATION;
   if (unused_since_prefetch)
     flags |= RESPONSE_INFO_UNUSED_SINCE_PREFETCH;
   if (!ssl_info.signed_certificate_timestamps.empty())
     flags |= RESPONSE_INFO_HAS_SIGNED_CERTIFICATE_TIMESTAMPS;
+  if (ssl_info.pkp_bypassed)
+    flags |= RESPONSE_INFO_PKP_BYPASSED;
 
   pickle->WriteInt(flags);
   pickle->WriteInt64(request_time.ToInternalValue());
   pickle->WriteInt64(response_time.ToInternalValue());
 
   HttpResponseHeaders::PersistOptions persist_options =
       HttpResponseHeaders::PERSIST_RAW;
 
   if (skip_transient_headers) {
     persist_options = HttpResponseHeaders::PERSIST_SANS_COOKIES |
@@ skipping 83 matching lines @@
     case CONNECTION_INFO_QUIC1_SPDY3:
       return "quic/1+spdy/3";
     case NUM_OF_CONNECTION_INFOS:
       break;
   }
   NOTREACHED();
   return "";
 }
 
 }  // namespace net