[DO NOT SUBMIT, PATCH on commit 7fa349e632a44c152b05ca6a66ade5f2e5b3f139]

net/quic/chromium/quic_chromium_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/chromium/quic_chromium_client_session.h"
 
 #include <utility>
 
 #include "base/callback_helpers.h"
 #include "base/location.h"
@@ skipping 232 matching lines @@
     QuicCryptoClientConfig* crypto_config,
     const char* const connection_description,
     base::TimeTicks dns_resolution_start_time,
     base::TimeTicks dns_resolution_end_time,
     QuicClientPushPromiseIndex* push_promise_index,
     ServerPushDelegate* push_delegate,
     base::TaskRunner* task_runner,
     std::unique_ptr<SocketPerformanceWatcher> socket_performance_watcher,
     NetLog* net_log)
     : QuicClientSessionBase(connection, push_promise_index, config),
+      received_go_away_(false),
+      received_read_error_(false),
+      connection_closed_(false),
+      notified_session_going_away_(false),
+      notified_session_closed_later_(false),
+      notified_session_closed_(false),
       server_id_(server_id),
       require_confirmation_(require_confirmation),
       stream_factory_(stream_factory),
       transport_security_state_(transport_security_state),
       server_info_(std::move(server_info)),
       pkp_bypassed_(false),
       num_total_streams_(0),
       task_runner_(task_runner),
       net_log_(NetLogWithSource::Make(net_log, NetLogSourceType::QUIC_SESSION)),
       logger_(new QuicConnectionLogger(this,
@@ skipping 656 matching lines @@
     UMA_HISTOGRAM_CUSTOM_COUNTS("Net.QuicSession.RejectLength",
                                 message.GetSerialized().length(), 1000, 10000,
                                 50);
     base::StringPiece proof;
     UMA_HISTOGRAM_BOOLEAN("Net.QuicSession.RejectHasProof",
                           message.GetStringPiece(kPROF, &proof));
   }
 }
 
 void QuicChromiumClientSession::OnGoAway(const QuicGoAwayFrame& frame) {
+  received_go_away_ = true;
   QuicSession::OnGoAway(frame);
   NotifyFactoryOfSessionGoingAway();
   port_migration_detected_ = frame.error_code == QUIC_ERROR_MIGRATING_PORT;
 }
 
 void QuicChromiumClientSession::OnRstStream(const QuicRstStreamFrame& frame) {
   QuicSession::OnRstStream(frame);
   OnClosedStream();
 }
 
 void QuicChromiumClientSession::OnConnectionClosed(
     QuicErrorCode error,
     const std::string& error_details,
     ConnectionCloseSource source) {
+  connection_closed_ = true;
   DCHECK(!connection()->connected());
   logger_->OnConnectionClosed(error, error_details, source);
   if (source == ConnectionCloseSource::FROM_PEER) {
     if (IsCryptoHandshakeConfirmed()) {
       UMA_HISTOGRAM_SPARSE_SLOWLY(
           "Net.QuicSession.ConnectionCloseErrorCodeServer.HandshakeConfirmed",
           error);
       base::HistogramBase* histogram = base::SparseHistogram::FactoryGet(
           "Net.QuicSession.StreamCloseErrorCodeServer.HandshakeConfirmed",
           base::HistogramBase::kUmaTargetedHistogramFlag);
@@ skipping 376 matching lines @@
 }
 
 base::WeakPtr<QuicChromiumClientSession>
 QuicChromiumClientSession::GetWeakPtr() {
   return weak_factory_.GetWeakPtr();
 }
 
 void QuicChromiumClientSession::OnReadError(
     int result,
     const DatagramClientSocket* socket) {
+  received_read_error_ = true;
   DCHECK(socket != nullptr);
   if (socket != GetDefaultSocket()) {
     // Ignore read errors from old sockets that are no longer active.
     // TODO(jri): Maybe clean up old sockets on error.
     return;
   }
   DVLOG(1) << "Closing session on read error: " << result;
   UMA_HISTOGRAM_SPARSE_SLOWLY("Net.QuicSession.ReadError", -result);
   NotifyFactoryOfSessionGoingAway();
   CloseSessionOnErrorInner(result, QUIC_PACKET_READ_ERROR);
   NotifyFactoryOfSessionClosedLater();
 }
 
 bool QuicChromiumClientSession::OnPacket(const QuicReceivedPacket& packet,
                                          IPEndPoint local_address,
                                          IPEndPoint peer_address) {
   ProcessUdpPacket(QuicSocketAddress(QuicSocketAddressImpl(local_address)),
                    QuicSocketAddress(QuicSocketAddressImpl(peer_address)),
                    packet);
   if (!connection()->connected()) {
     NotifyFactoryOfSessionClosedLater();
     return false;
   }
   return true;
 }
 
 void QuicChromiumClientSession::NotifyFactoryOfSessionGoingAway() {
+  notified_session_going_away_ = true;
   going_away_ = true;
   if (stream_factory_)
     stream_factory_->OnSessionGoingAway(this);
 }
 
 void QuicChromiumClientSession::NotifyFactoryOfSessionClosedLater() {
+  notified_session_closed_later_ = true;
   if (!dynamic_streams().empty())
     RecordUnexpectedOpenStreams(NOTIFY_FACTORY_OF_SESSION_CLOSED_LATER);
 
   if (!going_away_)
     RecordUnexpectedNotGoingAway(NOTIFY_FACTORY_OF_SESSION_CLOSED_LATER);
 
   going_away_ = true;
   DCHECK_EQ(0u, GetNumActiveStreams());
   DCHECK(!connection()->connected());
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&QuicChromiumClientSession::NotifyFactoryOfSessionClosed,
                  weak_factory_.GetWeakPtr()));
 }
 
 void QuicChromiumClientSession::NotifyFactoryOfSessionClosed() {
+  notified_session_closed_ = true;
   if (!dynamic_streams().empty())
     RecordUnexpectedOpenStreams(NOTIFY_FACTORY_OF_SESSION_CLOSED);
 
   if (!going_away_)
     RecordUnexpectedNotGoingAway(NOTIFY_FACTORY_OF_SESSION_CLOSED);
 
   going_away_ = true;
   DCHECK_EQ(0u, GetNumActiveStreams());
   // Will delete |this|.
   if (stream_factory_)
@@ skipping 122 matching lines @@
 }
 
 size_t QuicChromiumClientSession::EstimateMemoryUsage() const {
   // TODO(xunjieli): Estimate |crypto_stream_|, QuicSpdySession's
   // QuicHeaderList, QuicSession's QuiCWriteBlockedList, open streams and
   // unacked packet map.
   return base::trace_event::EstimateMemoryUsage(packet_readers_);
 }
 
 }  // namespace net