Land Recent QUIC Changes.

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 138 matching lines @@
       require_confirmation_(false),
       stream_factory_(stream_factory),
       socket_(socket.Pass()),
       writer_(writer.Pass()),
       read_buffer_(new IOBufferWithSize(kMaxPacketSize)),
       server_info_(server_info.Pass()),
       read_pending_(false),
       num_total_streams_(0),
       task_runner_(task_runner),
       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_QUIC_SESSION)),
-      logger_(net_log_),
+      logger_(new QuicConnectionLogger(net_log_)),
       num_packets_read_(0),
       going_away_(false),
       weak_factory_(this) {
   crypto_stream_.reset(
       crypto_client_stream_factory ?
           crypto_client_stream_factory->CreateQuicCryptoClientStream(
               server_id, this, crypto_config) :
           new QuicCryptoClientStream(server_id, this,
                                      new ProofVerifyContextChromium(net_log_),
                                      crypto_config));
 
-  connection->set_debug_visitor(&logger_);
+  connection->set_debug_visitor(logger_);
   // TODO(rch): pass in full host port proxy pair
   net_log_.BeginEvent(
       NetLog::TYPE_QUIC_SESSION,
       NetLog::StringCallback("host", &server_id.host()));
 }
 
 QuicClientSession::~QuicClientSession() {
   if (!streams()->empty())
     RecordUnexpectedOpenStreams(DESTRUCTOR);
   if (!observers_.empty())
@@ skipping 332 matching lines @@
 
 QuicDataStream* QuicClientSession::CreateIncomingDataStream(
     QuicStreamId id) {
   DLOG(ERROR) << "Server push not supported";
   return NULL;
 }
 
 void QuicClientSession::CloseStream(QuicStreamId stream_id) {
   ReliableQuicStream* stream = GetStream(stream_id);
   if (stream) {
-    logger_.UpdateReceivedFrameCounts(
+    logger_->UpdateReceivedFrameCounts(
         stream_id, stream->num_frames_received(),
         stream->num_duplicate_frames_received());
   }
   QuicSession::CloseStream(stream_id);
   OnClosedStream();
 }
 
 void QuicClientSession::SendRstStream(QuicStreamId id,
                                       QuicRstStreamErrorCode error,
                                       QuicStreamOffset bytes_written) {
@@ skipping 35 matching lines @@
       Observer* observer = *it;
       ++it;
       observer->OnCryptoHandshakeConfirmed();
     }
   }
   QuicSession::OnCryptoHandshakeEvent(event);
 }
 
 void QuicClientSession::OnCryptoHandshakeMessageSent(
     const CryptoHandshakeMessage& message) {
-  logger_.OnCryptoHandshakeMessageSent(message);
+  logger_->OnCryptoHandshakeMessageSent(message);
 }
 
 void QuicClientSession::OnCryptoHandshakeMessageReceived(
     const CryptoHandshakeMessage& message) {
-  logger_.OnCryptoHandshakeMessageReceived(message);
+  logger_->OnCryptoHandshakeMessageReceived(message);
 }
 
 void QuicClientSession::OnConnectionClosed(QuicErrorCode error,
                                            bool from_peer) {
   DCHECK(!connection()->connected());
-  logger_.OnConnectionClosed(error, from_peer);
+  logger_->OnConnectionClosed(error, from_peer);
   if (from_peer) {
     UMA_HISTOGRAM_SPARSE_SLOWLY(
         "Net.QuicSession.ConnectionCloseErrorCodeServer", error);
   } else {
     UMA_HISTOGRAM_SPARSE_SLOWLY(
         "Net.QuicSession.ConnectionCloseErrorCodeClient", error);
   }
 
   if (error == QUIC_CONNECTION_TIMED_OUT) {
     UMA_HISTOGRAM_COUNTS(
@@ skipping 34 matching lines @@
   socket_->Close();
   QuicSession::OnConnectionClosed(error, from_peer);
   DCHECK(streams()->empty());
   CloseAllStreams(ERR_UNEXPECTED);
   CloseAllObservers(ERR_UNEXPECTED);
   NotifyFactoryOfSessionClosedLater();
 }
 
 void QuicClientSession::OnSuccessfulVersionNegotiation(
     const QuicVersion& version) {
-  logger_.OnSuccessfulVersionNegotiation(version);
+  logger_->OnSuccessfulVersionNegotiation(version);
   QuicSession::OnSuccessfulVersionNegotiation(version);
 }
 
 void QuicClientSession::OnProofValid(
     const QuicCryptoClientConfig::CachedState& cached) {
   DCHECK(cached.proof_valid());
 
   if (!server_info_ || !server_info_->IsReadyToPersist()) {
     return;
   }
 
   QuicServerInfo::State* state = server_info_->mutable_state();
 
   state->server_config = cached.server_config();
   state->source_address_token = cached.source_address_token();
   state->server_config_sig = cached.signature();
   state->certs = cached.certs();
 
   server_info_->Persist();
 }
 
 void QuicClientSession::OnProofVerifyDetailsAvailable(
     const ProofVerifyDetails& verify_details) {
   const CertVerifyResult* cert_verify_result_other =
       &(reinterpret_cast<const ProofVerifyDetailsChromium*>(
           &verify_details))->cert_verify_result;
   CertVerifyResult* result_copy = new CertVerifyResult;
   result_copy->CopyFrom(*cert_verify_result_other);
   cert_verify_result_.reset(result_copy);
-  logger_.OnCertificateVerified(*cert_verify_result_);
+  logger_->OnCertificateVerified(*cert_verify_result_);
 }
 
 void QuicClientSession::StartReading() {
   if (read_pending_) {
     return;
   }
   read_pending_ = true;
   int rv = socket_->Read(read_buffer_.get(),
                          read_buffer_->size(),
                          base::Bind(&QuicClientSession::OnReadComplete,
@@ skipping 169 matching lines @@
     return;
 
   // TODO(rch): re-enable this code once beta is cut.
   //  if (stream_factory_)
   //    stream_factory_->OnSessionConnectTimeout(this);
   //  CloseAllStreams(ERR_QUIC_HANDSHAKE_FAILED);
   //  DCHECK_EQ(0u, GetNumOpenStreams());
 }
 
 }  // namespace net