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/crypto/proof_verifier.h"
 #include "net/quic/quic_connection.h"
 #include "net/ssl/ssl_info.h"
@@ skipping 161 matching lines @@
   if (ContainsKey(zombie_streams_, stream->id())) {
     // If this was a zombie stream then we close it out now.
     CloseZombieStream(stream->id());
     // However, since the headers still have not been decompressed, we want to
     // mark it a prematurely closed so that if we ever receive frames
     // for this stream we can close the connection.
     DCHECK(!stream->headers_decompressed());
     AddPrematurelyClosedStream(frame.stream_id);
     return;
   }
+  if (stream->stream_bytes_read() > 0 && !stream->headers_decompressed()) {
+    connection()->SendConnectionClose(
+        QUIC_STREAM_RST_BEFORE_HEADERS_DECOMPRESSED);
+  }
   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::OnConnectionClosed(QuicErrorCode error, bool from_peer) {
   DCHECK(!connection_->connected());
@@ skipping 15 matching lines @@
 }
 
 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_.NumBlockedStreams();
 
   while (!connection_->HasQueuedData() &&
          remaining_writes > 0) {
     DCHECK(write_blocked_streams_.HasWriteBlockedStreams());
-    int index = write_blocked_streams_.GetHighestPriorityWriteBlockedList();
-    if (index == -1) {
+    if (!write_blocked_streams_.HasWriteBlockedStreams()) {
       LOG(DFATAL) << "WriteBlockedStream is missing";
       connection_->CloseConnection(QUIC_INTERNAL_ERROR, false);
       return true;  // We have no write blocked streams.
     }
+    int index = write_blocked_streams_.GetHighestPriorityWriteBlockedList();
     QuicStreamId stream_id = write_blocked_streams_.PopFront(index);
     if (stream_id == kCryptoStreamId) {
       has_pending_handshake_ = false;  // We just popped it.
     }
     ReliableQuicStream* stream = GetStream(stream_id);
     if (stream != NULL) {
       // If the stream can't write all bytes, it'll re-add itself to the blocked
       // list.
       stream->OnCanWrite();
     }
     --remaining_writes;
   }
 
   return !write_blocked_streams_.HasWriteBlockedStreams();
 }
 
 bool QuicSession::HasPendingHandshake() const {
   return has_pending_handshake_;
 }
 
-QuicConsumedData QuicSession::WritevData(QuicStreamId id,
-                                         const struct iovec* iov,
-                                         int iov_count,
-                                         QuicStreamOffset offset,
-                                         bool fin) {
+QuicConsumedData QuicSession::WritevData(
+    QuicStreamId id,
+    const struct iovec* iov,
+    int iov_count,
+    QuicStreamOffset offset,
+    bool fin,
+    QuicAckNotifier::DelegateInterface* ack_notifier_delegate) {
   IOVector data;
   data.AppendIovec(iov, iov_count);
-  return connection_->SendStreamData(id, data, offset, fin, NULL);
+  return connection_->SendStreamData(id, data, offset, fin,
+                                     ack_notifier_delegate);
 }
 
 void QuicSession::SendRstStream(QuicStreamId id,
                                 QuicRstStreamErrorCode error) {
   connection_->SendRstStream(id, error);
   CloseStreamInner(id, true);
 }
 
 void QuicSession::SendGoAway(QuicErrorCode error_code, const string& reason) {
   goaway_sent_ = true;
@@ skipping 246 matching lines @@
   NOTIMPLEMENTED();
   return false;
 }
 
 void QuicSession::PostProcessAfterData() {
   STLDeleteElements(&closed_streams_);
   closed_streams_.clear();
 }
 
 }  // namespace net