Deprecate old PublicKeyPinFailureDomain histogram

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"
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 #include <vector>
@@ skipping 374 matching lines @@
 
  private:
   const uint8_t* const tree_;
   const size_t tree_bytes_;
 };
 
 // PreloadResult is the result of resolving a specific name in the preloaded
 // data.
 struct PreloadResult {
   uint32_t pinset_id;
-  uint32_t 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 sts_include_subdomains;
   bool pkp_include_subdomains;
   bool force_https;
   bool has_pins;
   bool expect_ct;
   uint32_t expect_ct_report_uri_id;
   bool expect_staple;
@@ skipping 111 matching lines @@
       if (c == kEndOfString) {
         PreloadResult tmp;
         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) {
+          uint32_t unused_domain_id;
           if (!reader.Read(4, &tmp.pinset_id) ||
-              !reader.Read(9, &tmp.domain_id) ||
+              !reader.Read(9, &unused_domain_id) ||

[davidben, 2016/11/01 17:20:22]

Could you file a bug to get rid of this and link it here? (Maybe for lgarron
since he's managing the list.) I'm not familiar enough with the format to know
if it'd make it more compact, but freeing up 9 bits seems valuable.

[estark, 2016/11/01 17:25:47]

Done (bug 661206).

               (!tmp.sts_include_subdomains &&
                !reader.Next(&tmp.pkp_include_subdomains))) {
             return false;
           }
         }
 
         if (!reader.Next(&tmp.expect_ct))
           return false;
 
         if (tmp.expect_ct) {
@@ skipping 232 matching lines @@
   PKPStatus pin_validity = CheckPublicKeyPinsImpl(
       host_port_pair, is_issued_by_known_root, public_key_hashes,
       served_certificate_chain, validated_certificate_chain, report_status,
       pinning_failure_log);
 
   // Don't track statistics when a local trust anchor would override the pinning
   // anyway.
   if (!is_issued_by_known_root)
     return pin_validity;
 
-  if (pin_validity == PKPStatus::VIOLATED) {
-    LOG(ERROR) << *pinning_failure_log;
-    ReportUMAOnPinFailure(host_port_pair.host());
-  }
   UMA_HISTOGRAM_BOOLEAN("Net.PublicKeyPinSuccess",
                         pin_validity == PKPStatus::OK);
   return pin_validity;
 }
 
 void TransportSecurityState::CheckExpectStaple(
     const HostPortPair& host_port_pair,
     const SSLInfo& ssl_info,
     const std::string& ocsp_response) {
   DCHECK(CalledOnValidThread());
@@ skipping 552 matching lines @@
   UMA_HISTOGRAM_ENUMERATION("Net.ExpectCTHeaderResult", result,
                             EXPECT_CT_HEADER_LAST + 1);
   if (result != EXPECT_CT_HEADER_PROCESSED)
     return;
 
   expect_ct_reporter_->OnExpectCTFailed(host_port_pair, state.report_uri,
                                         ssl_info);
 }
 
 // static
-void TransportSecurityState::ReportUMAOnPinFailure(const std::string& host) {
-  PreloadResult result;
-  if (!DecodeHSTSPreload(host, &result) ||
-      !result.has_pins) {
-    return;
-  }
-
-  DCHECK(result.domain_id != DOMAIN_NOT_PINNED);
-
-  UMA_HISTOGRAM_SPARSE_SLOWLY(
-      "Net.PublicKeyPinFailureDomain", result.domain_id);
-}
-
-// static
 void TransportSecurityState::SetShouldRequireCTForTesting(bool* required) {
   if (!required) {
     g_ct_required_for_testing = 0;
     return;
   }
   g_ct_required_for_testing = *required ? 1 : -1;
 }
 
 // static
 bool TransportSecurityState::IsBuildTimely() {
@@ skipping 278 matching lines @@
 TransportSecurityState::PKPStateIterator::PKPStateIterator(
     const TransportSecurityState& state)
     : iterator_(state.enabled_pkp_hosts_.begin()),
       end_(state.enabled_pkp_hosts_.end()) {
 }
 
 TransportSecurityState::PKPStateIterator::~PKPStateIterator() {
 }
 
 }  // namespace