Gather metrics classifying the cause of the TLS fallback.

net/http/http_network_transaction.cc

Index: net/http/http_network_transaction.cc
diff --git a/net/http/http_network_transaction.cc b/net/http/http_network_transaction.cc
index 981fcb6abb003efef8362d272967df28d96309e0..8fd0595cf47d824727bf4a0c48ef2c74aeb579e8 100644
--- a/net/http/http_network_transaction.cc
+++ b/net/http/http_network_transaction.cc
@@ -95,12 +95,14 @@ void ProcessAlternateProtocol(
 base::Value* NetLogSSLVersionFallbackCallback(
     const GURL* url,
     int net_error,
+    SSLFailureState ssl_failure_state,
     uint16 version_before,
     uint16 version_after,
     NetLogCaptureMode /* capture_mode */) {
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetString("host_and_port", GetHostAndPort(*url));
   dict->SetInteger("net_error", net_error);
+  dict->SetInteger("ssl_failure_state", ssl_failure_state);
   dict->SetInteger("version_before", version_before);
   dict->SetInteger("version_after", version_after);
   return dict;
@@ -129,7 +131,9 @@ HttpNetworkTransaction::HttpNetworkTransaction(RequestPriority priority,
       request_(NULL),
       priority_(priority),
       headers_valid_(false),
+      server_ssl_failure_state_(kSSLFailureNone),
       fallback_error_code_(ERR_SSL_INAPPROPRIATE_FALLBACK),
+      fallback_failure_state_(kSSLFailureNone),
       request_headers_(),
       read_buf_len_(0),
       total_received_bytes_(0),
@@ -502,12 +506,14 @@ void HttpNetworkTransaction::OnWebSocketHandshakeStreamReady(
 }
 
 void HttpNetworkTransaction::OnStreamFailed(int result,
-                                            const SSLConfig& used_ssl_config) {
+                                            const SSLConfig& used_ssl_config,
+                                            SSLFailureState ssl_failure_state) {
   DCHECK_EQ(STATE_CREATE_STREAM_COMPLETE, next_state_);
   DCHECK_NE(OK, result);
   DCHECK(stream_request_.get());
   DCHECK(!stream_.get());
   server_ssl_config_ = used_ssl_config;
+  server_ssl_failure_state_ = ssl_failure_state;
 
   OnIOComplete(result);
 }
@@ -1351,10 +1357,11 @@ int HttpNetworkTransaction::HandleSSLHandshakeError(int error) {
   if (should_fallback) {
     net_log_.AddEvent(
         NetLog::TYPE_SSL_VERSION_FALLBACK,
-        base::Bind(&NetLogSSLVersionFallbackCallback,
-                   &request_->url, error, server_ssl_config_.version_max,
+        base::Bind(&NetLogSSLVersionFallbackCallback, &request_->url, error,
+                   server_ssl_failure_state_, server_ssl_config_.version_max,
                    version_max));
     fallback_error_code_ = error;
+    fallback_failure_state_ = server_ssl_failure_state_;
     server_ssl_config_.version_max = version_max;
     server_ssl_config_.version_fallback = true;
     ResetConnectionAndRequestForResend();
@@ -1473,6 +1480,16 @@ void HttpNetworkTransaction::RecordSSLFallbackMetrics() {
 
   UMA_HISTOGRAM_BOOLEAN("Net.ConnectionUsedSSLDeprecatedCipherFallback2",
                         server_ssl_config_.enable_deprecated_cipher_suites);
+
+  if (server_ssl_config_.version_fallback) {
+    // Record the error code which triggered the fallback and the state the
+    // handshake was in.
+    UMA_HISTOGRAM_CUSTOM_ENUMERATION("Net.SSLFallbackErrorCode",
+                                     -fallback_error_code_,
+                                     net::GetAllErrorCodesForUma());

[Alexei Svitkine (slow), 2015/05/15 14:39:36]

It's more efficient to use UMA_HISTOGRAM_SPARSE_SLOWLY() in this case, instead
of allocating an array to hold all possible bucket values.

[davidben, 2015/05/15 18:00:23]

Done.

In that case should we switch all code that currently uses
net::GetAllErrorCodesForUma() or is that incompatible? There's a few places. I
can do it in a follow-up if SPARSE_SLOWLY is preferred.

https://code.google.com/p/chromium/codesearch#search/&q=GetAllErrorCodesForUm...

[Alexei Svitkine (slow), 2015/05/15 18:05:22]

Yes, preferably all the places should be switched.

+    UMA_HISTOGRAM_ENUMERATION("Net.SSLFallbackFailureState",
+                              fallback_failure_state_, kSSLFailureMax);
+  }
 }
 
 HttpResponseHeaders* HttpNetworkTransaction::GetResponseHeaders() const {