Add a new UMA histogram for tracking SpdySessionErrorDetails

net/spdy/spdy_session.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/spdy/spdy_session.h"
 
 #include <map>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 479 matching lines @@
   CHECK_NE(state_, CLOSED);
 
   *stream = NULL;
 
   // Don't allow access to secure push streams over an unauthenticated, but
   // encrypted SSL socket.
   if (is_secure_ && certificate_error_code_ != OK &&
       (url.SchemeIs("https") || url.SchemeIs("wss"))) {
     CloseSessionOnError(
         static_cast<net::Error>(certificate_error_code_),
+        REQUST_FOR_SECURE_CONTENT_OVER_INSECURE_SESSION,
         true,
         "Tried to get SPDY stream for secure content over an unauthenticated "
         "session.");
     return ERR_SPDY_PROTOCOL_ERROR;
   }
 
   *stream = GetActivePushStream(url.spec());
   if (stream->get()) {
     DCHECK(streams_pushed_and_claimed_count_ < streams_pushed_count_);
     streams_pushed_and_claimed_count_++;
@@ skipping 82 matching lines @@
     const BoundNetLog& stream_net_log) {
   DCHECK_GE(priority, MINIMUM_PRIORITY);
   DCHECK_LT(priority, NUM_PRIORITIES);
 
   // Make sure that we don't try to send https/wss over an unauthenticated, but
   // encrypted SSL socket.
   if (is_secure_ && certificate_error_code_ != OK &&
       (url.SchemeIs("https") || url.SchemeIs("wss"))) {
     CloseSessionOnError(
         static_cast<net::Error>(certificate_error_code_),
+        REQUST_FOR_SECURE_CONTENT_OVER_INSECURE_SESSION,
         true,
         "Tried to create SPDY stream for secure content over an "
         "unauthenticated session.");
     return ERR_SPDY_PROTOCOL_ERROR;
   }
 
   const std::string& path = url.PathForRequest();
 
   const SpdyStreamId stream_id = GetNewStreamId();
 
@@ skipping 257 matching lines @@
   // buffer (32KB).
   // TODO(mbelshe): support arbitrarily large frames!
 
   read_pending_ = false;
 
   if (bytes_read <= 0) {
     // Session is tearing down.
     net::Error error = static_cast<net::Error>(bytes_read);
     if (bytes_read == 0)
       error = ERR_CONNECTION_CLOSED;
-    CloseSessionOnError(error, true, "bytes_read is <= 0.");
+    CloseSessionOnError(error, READ_FAILED, true,
+                        "bytes_read is <= 0.");
     return;
   }
 
   bytes_received_ += bytes_read;
 
   received_data_time_ = base::TimeTicks::Now();
 
   // The SpdyFramer will use callbacks onto |this| as it parses frames.
   // When errors occur, those callbacks can lead to teardown of all references
   // to |this|, so maintain a reference to self during this call for safe
@@ skipping 57 matching lines @@
 
     // Write more data.  We're already in a continuation, so we can
     // go ahead and write it immediately (without going back to the
     // message loop).
     WriteSocketLater();
   } else {
     in_flight_write_.release();
 
     // The stream is now errored.  Close it down.
     CloseSessionOnError(
-        static_cast<net::Error>(result), true, "The stream has errored.");
+        static_cast<net::Error>(result), WRITE_FAILED, true,
+        "The stream has errored.");
   }
 }
 
 net::Error SpdySession::ReadSocket() {
   if (read_pending_)
     return OK;
 
   if (state_ == CLOSED) {
     NOTREACHED();
     return ERR_UNEXPECTED;
   }
 
   CHECK(connection_.get());
   CHECK(connection_->socket());
   int bytes_read = connection_->socket()->Read(
       read_buffer_.get(),
       kReadBufferSize,
       base::Bind(&SpdySession::OnReadComplete, base::Unretained(this)));
   switch (bytes_read) {
     case 0:
       // Socket is closed!
-      CloseSessionOnError(ERR_CONNECTION_CLOSED, true, "bytes_read is 0.");
+      CloseSessionOnError(ERR_CONNECTION_CLOSED, READ_FAILED, true,
+                          "bytes_read is 0.");
       return ERR_CONNECTION_CLOSED;
     case net::ERR_IO_PENDING:
       // Waiting for data.  Nothing to do now.
       read_pending_ = true;
       return ERR_IO_PENDING;
     default:
       // Data was read, process it.
       // Schedule the work through the message loop to avoid recursive
       // callbacks.
       read_pending_ = true;
@@ skipping 46 matching lines @@
       // which is now.  At this time, we don't compress our data frames.
       SpdyFrame uncompressed_frame(next_buffer.buffer()->data(), false);
       size_t size;
       if (buffered_spdy_framer_->IsCompressible(uncompressed_frame)) {
         DCHECK(uncompressed_frame.is_control_frame());
         scoped_ptr<SpdyFrame> compressed_frame(
             buffered_spdy_framer_->CompressControlFrame(
                 reinterpret_cast<const SpdyControlFrame&>(uncompressed_frame)));
         if (!compressed_frame.get()) {
           CloseSessionOnError(
-              net::ERR_SPDY_PROTOCOL_ERROR, true, "SPDY Compression failure.");
+              net::ERR_SPDY_PROTOCOL_ERROR, SPDY_COMPRESSION_FAILURE, true,
+              "SPDY Compression failure.");
           return;
         }
 
         size = compressed_frame->length() + SpdyFrame::kHeaderSize;
 
         DCHECK_GT(size, 0u);
 
         // TODO(mbelshe): We have too much copying of data here.
         IOBufferWithSize* buffer = new IOBufferWithSize(size);
         memcpy(buffer->data(), compressed_frame->data(), size);
@@ skipping 76 matching lines @@
                              SpdyStream* stream) {
   int length = SpdyFrame::kHeaderSize + frame->length();
   IOBuffer* buffer = new IOBuffer(length);
   memcpy(buffer->data(), frame->data(), length);
   queue_.push(SpdyIOBuffer(buffer, length, priority, stream));
 
   WriteSocketLater();
 }
 
 void SpdySession::CloseSessionOnError(net::Error err,
+                                      SpdySessionErrorDetails details,
                                       bool remove_from_pool,
                                       const std::string& description) {
+  UMA_HISTOGRAM_ENUMERATION("Net.SpdySessionErrorDetails", details,
+                            NUM_SPDY_SESSION_ERROR_DETAILS);
+  if (EndsWith(host_port_pair().host(), "google.com", false)) {
+    UMA_HISTOGRAM_ENUMERATION("Net.SpdySessionErrorDetails_Google", details,
+                              NUM_SPDY_SESSION_ERROR_DETAILS);
+  }
   // Closing all streams can have a side-effect of dropping the last reference
   // to |this|.  Hold a reference through this function.
   scoped_refptr<SpdySession> self(this);
 
   DCHECK_LT(err, OK);
   net_log_.AddEvent(
       NetLog::TYPE_SPDY_SESSION_CLOSE,
       make_scoped_refptr(
           new NetLogSpdySessionCloseParameter(err, description)));
 
@@ skipping 160 matching lines @@
     return NULL;
   return GetSSLClientSocket()->GetServerBoundCertService();
 }
 
 SSLClientCertType SpdySession::GetDomainBoundCertType() const {
   if (!is_secure_)
     return CLIENT_CERT_INVALID_TYPE;
   return GetSSLClientSocket()->domain_bound_cert_type();
 }
 
-void SpdySession::OnError(int error_code) {
+void SpdySession::OnError(SpdyFramer::SpdyError error_code) {
   std::string description = base::StringPrintf(
       "SPDY_ERROR error_code: %d.", error_code);
-  CloseSessionOnError(net::ERR_SPDY_PROTOCOL_ERROR, true, description);
+  CloseSessionOnError(net::ERR_SPDY_PROTOCOL_ERROR,
+                      static_cast<SpdySessionErrorDetails>(error_code),
+                      true, description);
 }
 
 void SpdySession::OnStreamError(SpdyStreamId stream_id,
                                 const std::string& description) {
   if (IsStreamActive(stream_id))
     ResetStream(stream_id, PROTOCOL_ERROR, description);
 }
 
 void SpdySession::OnStreamFrameData(SpdyStreamId stream_id,
                                     const char* data,
@@ skipping 275 matching lines @@
 
   // Send response to a PING from server.
   if (frame.unique_id() % 2 == 0) {
     WritePingFrame(frame.unique_id());
     return;
   }
 
   --pings_in_flight_;
   if (pings_in_flight_ < 0) {
     CloseSessionOnError(
-        net::ERR_SPDY_PROTOCOL_ERROR, true, "pings_in_flight_ is < 0.");
+        net::ERR_SPDY_PROTOCOL_ERROR, UNEXPECTED_PING, true,
+        "pings_in_flight_ is < 0.");
     return;
   }
 
   if (pings_in_flight_ > 0)
     return;
 
   // We will record RTT in histogram when there are no more client sent
   // pings_in_flight_.
   RecordPingRTTHistogram(base::TimeTicks::Now() - last_ping_sent_time_);
 
@@ skipping 219 matching lines @@
     check_ping_status_pending_ = false;
     return;
   }
 
   DCHECK(check_ping_status_pending_);
 
   base::TimeTicks now = base::TimeTicks::Now();
   base::TimeDelta delay = hung_interval_ - (now - received_data_time_);
 
   if (delay.InMilliseconds() < 0 || received_data_time_ < last_check_time) {
-    CloseSessionOnError(net::ERR_SPDY_PING_FAILED, true, "Failed ping.");
+    CloseSessionOnError(net::ERR_SPDY_PING_FAILED, PING_FAILED, true,
+                        "Failed ping.");
     // Track all failed PING messages in a separate bucket.
     const base::TimeDelta kFailedPing =
         base::TimeDelta::FromInternalValue(INT_MAX);
     RecordPingRTTHistogram(kFailedPing);
     return;
   }
 
   // Check the status of connection after a delay.
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
@@ skipping 93 matching lines @@
 SSLClientSocket* SpdySession::GetSSLClientSocket() const {
   if (!is_secure_)
     return NULL;
   SSLClientSocket* ssl_socket =
       reinterpret_cast<SSLClientSocket*>(connection_->socket());
   DCHECK(ssl_socket);
   return ssl_socket;
 }
 
 }  // namespace net