Report a more specific QUIC error when reading from the socket fails.

net/quic/quic_client_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/quic/quic_client_session.h"
 
 #include "base/callback_helpers.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
@@ skipping 316 matching lines @@
   // Schedule the work through the message loop to avoid recursive
   // callbacks.
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&QuicClientSession::OnReadComplete,
                  weak_factory_.GetWeakPtr(), rv));
 }
 
 void QuicClientSession::CloseSessionOnError(int error) {
   UMA_HISTOGRAM_SPARSE_SLOWLY("Net.QuicSession.CloseSessionOnError", -error);
-  CloseSessionOnErrorInner(error);
+  CloseSessionOnErrorInner(error, QUIC_INTERNAL_ERROR);
   NotifyFactoryOfSessionClose();
 }
 
-void QuicClientSession::CloseSessionOnErrorInner(int error) {
+void QuicClientSession::CloseSessionOnErrorInner(int net_error,
+                                                 QuicErrorCode quic_error) {
   if (!callback_.is_null()) {
-    base::ResetAndReturn(&callback_).Run(error);
+    base::ResetAndReturn(&callback_).Run(net_error);
   }
   while (!streams()->empty()) {
     ReliableQuicStream* stream = streams()->begin()->second;
     QuicStreamId id = stream->id();
-    static_cast<QuicReliableClientStream*>(stream)->OnError(error);
+    static_cast<QuicReliableClientStream*>(stream)->OnError(net_error);
     CloseStream(id);
   }
   net_log_.AddEvent(
       NetLog::TYPE_QUIC_SESSION_CLOSE_ON_ERROR,
-      NetLog::IntegerCallback("net_error", error));
+      NetLog::IntegerCallback("net_error", net_error));
 
-  connection()->CloseConnection(QUIC_INTERNAL_ERROR, false);
+  connection()->CloseConnection(quic_error, false);
   DCHECK(!connection()->connected());
 }
 
 base::Value* QuicClientSession::GetInfoAsValue(const HostPortPair& pair) const {
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetString("host_port_pair", pair.ToString());
   dict->SetString("version", QuicVersionToString(connection()->version()));
   dict->SetInteger("open_streams", GetNumOpenStreams());
   dict->SetInteger("total_streams", num_total_streams_);
   dict->SetString("peer_address", peer_address().ToString());
   dict->SetString("guid", base::Uint64ToString(guid()));
   return dict;
 }
 
 base::WeakPtr<QuicClientSession> QuicClientSession::GetWeakPtr() {
   return weak_factory_.GetWeakPtr();
 }
 
 void QuicClientSession::OnReadComplete(int result) {
   read_pending_ = false;
   if (result == 0)
     result = ERR_CONNECTION_CLOSED;
 
   if (result < 0) {
     DLOG(INFO) << "Closing session on read error: " << result;
-    CloseSessionOnErrorInner(result);
+    UMA_HISTOGRAM_SPARSE_SLOWLY("Net.QuicSession.ReadError", -result);
+    CloseSessionOnErrorInner(result, QUIC_PACKET_READ_ERROR);
     NotifyFactoryOfSessionCloseLater();
     return;
   }
 
   scoped_refptr<IOBufferWithSize> buffer(read_buffer_);
   read_buffer_ = new IOBufferWithSize(kMaxPacketSize);
   QuicEncryptedPacket packet(buffer->data(), result);
   IPEndPoint local_address;
   IPEndPoint peer_address;
   socket_->GetLocalAddress(&local_address);
@@ skipping 18 matching lines @@
 }
 
 void QuicClientSession::NotifyFactoryOfSessionClose() {
   DCHECK_EQ(0u, GetNumOpenStreams());
   DCHECK(stream_factory_);
   // Will delete |this|.
   stream_factory_->OnSessionClose(this);
 }
 
 }  // namespace net