Report second-level domains for UMA on pin failure.

net/url_request/url_request_http_job.cc

 // Copyright (c) 2011 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/url_request/url_request_http_job.h"
 
 #include "base/bind.h"
 #include "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
@@ skipping 658 matching lines @@
   //
   // TODO(agl): we might have an issue here where a request for foo.example.com
   // merges into a SPDY connection to www.example.com, and gets a different
   // certificate.
   const SSLInfo& ssl_info = transaction_->GetResponseInfo()->ssl_info;
   if (result == OK &&
       ssl_info.is_valid() &&
       ssl_info.is_issued_by_known_root &&
       context_->transport_security_state()) {
     TransportSecurityState::DomainState domain_state;
-    bool sni = SSLConfigService::IsSNIAvailable(context_->ssl_config_service());
+    bool sni_available = SSLConfigService::IsSNIAvailable(
+        context_->ssl_config_service());
+    std::string host = request_->url().host();
+
     if (context_->transport_security_state()->HasPinsForHost(
-            &domain_state,
-            request_->url().host(), sni)) {
+            &domain_state, host, sni_available)) {
       if (!domain_state.IsChainOfPublicKeysPermitted(
               ssl_info.public_key_hashes)) {
         result = ERR_SSL_PINNED_KEY_NOT_IN_CERT_CHAIN;
         UMA_HISTOGRAM_BOOLEAN("Net.CertificatePinSuccess", false);
+        TransportSecurityState::ReportUMAOnPinFailure(host, sni_available);

[Chris Evans, 2011/10/26 22:49:46]

I don't think we need to pass sni_available; I think it's redundant? Assuming
so, passing less things is infinitely better. See comment in other file.

[palmer, 2011/10/27 01:15:45]

Done.

         FraudulentCertificateReporter* reporter =
             context_->fraudulent_certificate_reporter();
         if (reporter != NULL)
-          reporter->SendReport(request_->url().host(), ssl_info, sni);
+          reporter->SendReport(host, ssl_info, sni_available);
       } else {
         UMA_HISTOGRAM_BOOLEAN("Net.CertificatePinSuccess", true);
       }
     }
   }
 #endif
   if (result == OK) {
     scoped_refptr<HttpResponseHeaders> headers = GetResponseHeaders();
     if (request_->context() && request_->context()->network_delegate()) {
       // Note that |this| may not be deleted until
@@ skipping 405 matching lines @@
       if (postfilter_bytes_read() == expected_length) {
         // Clear the error.
         return true;
       }
     }
   }
   return false;
 }
 
 bool URLRequestHttpJob::ReadRawData(IOBuffer* buf, int buf_size,
-                                    int *bytes_read) {
+                                    int* bytes_read) {
   DCHECK_NE(buf_size, 0);
   DCHECK(bytes_read);
   DCHECK(!read_in_progress_);
 
   int rv = transaction_->Read(buf, buf_size, &read_callback_);
 
   if (ShouldFixMismatchedContentLength(rv))
     rv = 0;
 
   if (rv >= 0) {
@@ skipping 151 matching lines @@
       NOTREACHED();
       return;
   }
 }
 
 // The common type of histogram we use for all compression-tracking histograms.
 #define COMPRESSION_HISTOGRAM(name, sample) \
     do { \
       UMA_HISTOGRAM_CUSTOM_COUNTS("Net.Compress." name, sample, \
                                   500, 1000000, 100); \
-    } while(0)
+    } while (0)
 
 void URLRequestHttpJob::RecordCompressionHistograms() {
   DCHECK(request_);
   if (!request_)
     return;
 
   if (is_cached_content_ ||                // Don't record cached content
       !GetStatus().is_success() ||         // Don't record failed content
       !IsCompressibleContent() ||          // Only record compressible content
       !prefilter_bytes_read())       // Zero-byte responses aren't useful.
@@ skipping 128 matching lines @@
   return override_response_headers_.get() ?
       override_response_headers_ :
       transaction_->GetResponseInfo()->headers;
 }
 
 void URLRequestHttpJob::NotifyURLRequestDestroyed() {
   awaiting_callback_ = false;
 }
 
 }  // namespace net