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) {
+          // TODO(estark): This can be removed once the preload list
+          // format no longer includes |domain_id|.
+          // https://crbug.com/661206
+          uint32_t unused_domain_id;
           if (!reader.Read(4, &tmp.pinset_id) ||
-              !reader.Read(9, &tmp.domain_id) ||
+              !reader.Read(9, &unused_domain_id) ||
               (!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