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;
@@ skipping 58 matching lines @@
                          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),
       goaway_received_(false),
       goaway_sent_(false) {
-  connection->set_visitor(visitor_shim_.get());
+  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,
@@ skipping 17 matching lines @@
 
   for (size_t i = 0; i < frames.size(); ++i) {
     ReliableQuicStream* stream = GetStream(frames[i].stream_id);
     if (stream) {
       stream->OnStreamFrame(frames[i]);
     }
   }
 
   while (!decompression_blocked_streams_.empty()) {
     QuicHeaderId header_id = decompression_blocked_streams_.begin()->first;
-    if (header_id == decompressor_.current_header_id()) {
-      QuicStreamId stream_id = decompression_blocked_streams_.begin()->second;
-      decompression_blocked_streams_.erase(header_id);
-      ReliableQuicStream* stream = GetStream(stream_id);
-      if (!stream) {
-        connection()->SendConnectionClose(
-            QUIC_STREAM_RST_BEFORE_HEADERS_DECOMPRESSED);
-      }
-      stream->OnDecompressorAvailable();
+    if (header_id != decompressor_.current_header_id()) {
+      break;
     }
+    QuicStreamId stream_id = decompression_blocked_streams_.begin()->second;
+    decompression_blocked_streams_.erase(header_id);
+    ReliableQuicStream* stream = GetStream(stream_id);
+    if (!stream) {
+      connection()->SendConnectionClose(
+          QUIC_STREAM_RST_BEFORE_HEADERS_DECOMPRESSED);
+    }
+    stream->OnDecompressorAvailable();
   }
   return true;
 }
 
 void QuicSession::OnRstStream(const QuicRstStreamFrame& frame) {
   ReliableQuicStream* stream = GetStream(frame.stream_id);
   if (!stream) {
     return;  // Errors are handled by GetStream.
   }
   stream->OnStreamReset(frame.error_code);
@@ skipping 88 matching lines @@
     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())
           << "Handshake confirmed without parameter negotiation.";
-      connection_->SetConnectionTimeout(
+      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;
   }
 }
 
 QuicConfig* QuicSession::config() {
   return &config_;
@@ skipping 104 matching lines @@
                                            QuicStreamId stream_id) {
   decompression_blocked_streams_[header_id] = stream_id;
 }
 
 void QuicSession::PostProcessAfterData() {
   STLDeleteElements(&closed_streams_);
   closed_streams_.clear();
 }
 
 }  // namespace net