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 21 matching lines @@
     bool accepted = session_->OnPacket(self_address, peer_address, header,
                                        frame);
     session_->PostProcessAfterData();
     return accepted;
   }
   virtual void OnRstStream(const QuicRstStreamFrame& frame) OVERRIDE {
     session_->OnRstStream(frame);
     session_->PostProcessAfterData();
   }
 
-  virtual void OnAck(AckedPackets acked_packets) OVERRIDE {
+  virtual void OnGoAway(const QuicGoAwayFrame& frame) OVERRIDE {
+    session_->OnGoAway(frame);
+    session_->PostProcessAfterData();
+  }
+
+  virtual void OnAck(const SequenceNumberSet& acked_packets) OVERRIDE {
     session_->OnAck(acked_packets);
     session_->PostProcessAfterData();
   }
 
   virtual bool OnCanWrite() OVERRIDE {
     bool rc = session_->OnCanWrite();
     session_->PostProcessAfterData();
     return rc;
   }
 
   virtual void ConnectionClose(QuicErrorCode error, bool from_peer) OVERRIDE {
     session_->ConnectionClose(error, from_peer);
     // The session will go away, so don't bother with cleanup.
   }
 
  private:
   QuicSession* session_;
 };
 
 QuicSession::QuicSession(QuicConnection* connection, bool is_server)
     : connection_(connection),
       visitor_shim_(new VisitorShim(this)),
       max_open_streams_(kDefaultMaxStreamsPerConnection),
       next_stream_id_(is_server ? 2 : 3),
       is_server_(is_server),
-      largest_peer_created_stream_id_(0) {
+      largest_peer_created_stream_id_(0),
+      goaway_received_(false),
+      goaway_sent_(false) {
   connection->set_visitor(visitor_shim_.get());
 }
 
 QuicSession::~QuicSession() {
   STLDeleteElements(&closed_streams_);
   STLDeleteValues(&stream_map_);
 }
 
 bool QuicSession::OnPacket(const IPEndPoint& self_address,
                            const IPEndPoint& peer_address,
@@ skipping 23 matching lines @@
     }
   }
   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, frame.offset);
+  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) {
   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";
@@ skipping 20 matching lines @@
     --remaining_writes;
   }
 
   return write_blocked_streams_.empty();
 }
 
 QuicConsumedData QuicSession::WriteData(QuicStreamId id,
                                         StringPiece data,
                                         QuicStreamOffset offset,
                                         bool fin) {
-  // TODO(wtc): type mismatch -- connection_->SendStreamData() returns a
-  // size_t.
   return connection_->SendStreamData(id, data, offset, fin);
 }
 
 void QuicSession::SendRstStream(QuicStreamId id,
-                                QuicErrorCode error,
-                                QuicStreamOffset offset) {
-  connection_->SendRstStream(id, error, offset);
+                                QuicErrorCode error) {
+  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;
 
   ReliableStreamMap::iterator it = stream_map_.find(stream_id);
   if (it == stream_map_.end()) {
     DLOG(INFO) << "Stream is already closed: " << stream_id;
     return;
   }
   it->second->OnClose();
   closed_streams_.push_back(it->second);
@@ skipping 44 matching lines @@
 
   return GetIncomingReliableStream(stream_id);
 }
 
 ReliableQuicStream* QuicSession::GetIncomingReliableStream(
     QuicStreamId stream_id) {
   if (IsClosedStream(stream_id)) {
     return NULL;
   }
 
+  if (goaway_sent_) {
+    // We've already sent a GoAway
+    connection()->SendRstStream(stream_id, QUIC_PEER_GOING_AWAY);
+    return NULL;
+  }
+
   implicitly_created_streams_.erase(stream_id);
   if (stream_id > largest_peer_created_stream_id_) {
     // TODO(rch) add unit test for this
     if (stream_id - largest_peer_created_stream_id_ > kMaxStreamIdDelta) {
       connection()->SendConnectionClose(QUIC_INVALID_STREAM_ID);
       return NULL;
     }
     if (largest_peer_created_stream_id_ != 0) {
       for (QuicStreamId id = largest_peer_created_stream_id_ + 2;
            id < stream_id;
@@ skipping 38 matching lines @@
 void QuicSession::MarkWriteBlocked(QuicStreamId id) {
   write_blocked_streams_.push_back(id);
 }
 
 void QuicSession::PostProcessAfterData() {
   STLDeleteElements(&closed_streams_);
   closed_streams_.clear();
 }
 
 }  // namespace net