Land Recent QUIC changes.

net/quic/quic_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_session.h"
 
 #include "base/stl_util.h"
 #include "net/quic/quic_connection.h"
 
 using base::StringPiece;
 using base::hash_map;
 using base::hash_set;
 using std::vector;
 
 namespace net {
 
+#define ENDPOINT (is_server_ ? "Server: " : " Client: ")
+
 // We want to make sure we delete any closed streams in a safe manner.
 // To avoid deleting a stream in mid-operation, we have a simple shim between
 // us and the stream, so we can delete any streams when we return from
 // processing.
 //
 // We could just override the base methods, but this makes it easier to make
 // sure we don't miss any.
 class VisitorShim : public QuicConnectionVisitorInterface {
  public:
   explicit VisitorShim(QuicSession* session) : session_(session) {}
@@ skipping 40 matching lines @@
 QuicSession::QuicSession(QuicConnection* connection,
                          const QuicConfig& config,
                          bool is_server)
     : connection_(connection),
       visitor_shim_(new VisitorShim(this)),
       config_(config),
       max_open_streams_(kDefaultMaxStreamsPerConnection),
       next_stream_id_(is_server ? 2 : 3),
       is_server_(is_server),
       largest_peer_created_stream_id_(0),
+      error_(QUIC_NO_ERROR),
       goaway_received_(false),
       goaway_sent_(false) {
   set_max_open_streams(config_.max_streams_per_connection());
 
   connection_->set_visitor(visitor_shim_.get());
   connection_->SetIdleNetworkTimeout(config_.idle_connection_state_lifetime());
   connection_->SetOverallConnectionTimeout(
       config_.max_time_before_crypto_handshake());
   // TODO(satyamshekhar): Set congestion control and ICSL also.
 }
 
 QuicSession::~QuicSession() {
   STLDeleteElements(&closed_streams_);
   STLDeleteValues(&stream_map_);
 }
 
 bool QuicSession::OnPacket(const IPEndPoint& self_address,
                            const IPEndPoint& peer_address,
                            const QuicPacketHeader& header,
                            const vector<QuicStreamFrame>& frames) {
   if (header.public_header.guid != connection()->guid()) {
-    DLOG(INFO) << "Got packet header for invalid GUID: "
+    DLOG(INFO) << ENDPOINT << "Got packet header for invalid GUID: "
                << header.public_header.guid;
     return false;
   }
   for (size_t i = 0; i < frames.size(); ++i) {
     // TODO(rch) deal with the error case of stream id 0
     if (IsClosedStream(frames[i].stream_id)) continue;
 
     ReliableQuicStream* stream = GetStream(frames[i].stream_id);
     if (stream == NULL) return false;
     if (!stream->WillAcceptStreamFrame(frames[i])) return false;
@@ skipping 33 matching lines @@
   }
   stream->OnStreamReset(frame.error_code);
 }
 
 void QuicSession::OnGoAway(const QuicGoAwayFrame& frame) {
   DCHECK(frame.last_good_stream_id < next_stream_id_);
   goaway_received_ = true;
 }
 
 void QuicSession::ConnectionClose(QuicErrorCode error, bool from_peer) {
+  if (error_ == QUIC_NO_ERROR) {
+    error_ = error;
+  }
+
   while (stream_map_.size() != 0) {
     ReliableStreamMap::iterator it = stream_map_.begin();
     QuicStreamId id = it->first;
     it->second->ConnectionClose(error, from_peer);
     // The stream should call CloseStream as part of ConnectionClose.
     if (stream_map_.find(id) != stream_map_.end()) {
-      LOG(DFATAL) << "Stream failed to close under ConnectionClose";
+      LOG(DFATAL) << ENDPOINT << "Stream failed to close under ConnectionClose";
       CloseStream(id);
     }
   }
 }
 
 bool QuicSession::OnCanWrite() {
   // We latch this here rather than doing a traditional loop, because streams
   // may be modifying the list as we loop.
   int remaining_writes = write_blocked_streams_.NumObjects();
 
@@ skipping 25 matching lines @@
   connection_->SendRstStream(id, error);
   CloseStream(id);
 }
 
 void QuicSession::SendGoAway(QuicErrorCode error_code, const string& reason) {
   goaway_sent_ = true;
   connection_->SendGoAway(error_code, largest_peer_created_stream_id_, reason);
 }
 
 void QuicSession::CloseStream(QuicStreamId stream_id) {
-  DLOG(INFO) << "Closing stream " << stream_id;
+  DLOG(INFO) << ENDPOINT << "Closing stream " << stream_id;
 
   ReliableStreamMap::iterator it = stream_map_.find(stream_id);
   if (it == stream_map_.end()) {
-    DLOG(INFO) << "Stream is already closed: " << stream_id;
+    DLOG(INFO) << ENDPOINT << "Stream is already closed: " << stream_id;
     return;
   }
   ReliableQuicStream* stream = it->second;
   closed_streams_.push_back(it->second);
   stream_map_.erase(it);
   stream->OnClose();
 }
 
 bool QuicSession::IsEncryptionEstablished() {
   return GetCryptoStream()->encryption_established();
@@ skipping 11 matching lines @@
       break;
 
     case ENCRYPTION_REESTABLISHED:
       // Retransmit originally packets that were sent, since they can't be
       // decrypted by the peer.
       connection_->RetransmitUnackedPackets(
           QuicConnection::INITIAL_ENCRYPTION_ONLY);
       break;
 
     case HANDSHAKE_CONFIRMED:
-      LOG_IF(DFATAL, !config_.negotiated())
+      LOG_IF(DFATAL, !config_.negotiated()) << ENDPOINT
           << "Handshake confirmed without parameter negotiation.";
       connection_->SetIdleNetworkTimeout(
           config_.idle_connection_state_lifetime());
       connection_->SetOverallConnectionTimeout(QuicTime::Delta::Infinite());
       max_open_streams_ = config_.max_streams_per_connection();
       break;
 
     default:
-      LOG(ERROR) << "Got unknown handshake event: " << event;
+      LOG(ERROR) << ENDPOINT << "Got unknown handshake event: " << event;
   }
 }
 
 QuicConfig* QuicSession::config() {
   return &config_;
 }
 
 void QuicSession::ActivateStream(ReliableQuicStream* stream) {
-  DLOG(INFO) << "num_streams: " << stream_map_.size()
-            << ". activating " << stream->id();
+  DLOG(INFO) << ENDPOINT << "num_streams: " << stream_map_.size()
+             << ". activating " << stream->id();
   DCHECK(stream_map_.count(stream->id()) == 0);
   stream_map_[stream->id()] = stream;
 }
 
 QuicStreamId QuicSession::GetNextStreamId() {
   QuicStreamId id = next_stream_id_;
   next_stream_id_ += 2;
   return id;
 }
 
@@ skipping 89 matching lines @@
                                            QuicStreamId stream_id) {
   decompression_blocked_streams_[header_id] = stream_id;
 }
 
 void QuicSession::PostProcessAfterData() {
   STLDeleteElements(&closed_streams_);
   closed_streams_.clear();
 }
 
 }  // namespace net