WriteBlockedList for QUIC that prioritizes Crypto and Headers streams

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/quic/quic_headers_stream.h"
@@ skipping 263 matching lines @@
   int remaining_writes = write_blocked_streams_.NumBlockedStreams();
 
   while (!connection_->HasQueuedData() &&
          remaining_writes > 0) {
     DCHECK(write_blocked_streams_.HasWriteBlockedStreams());
     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);
+    QuicStreamId stream_id = write_blocked_streams_.PopFront();
     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;
@@ skipping 308 matching lines @@
 #endif
 
   if (id == kCryptoStreamId) {
     DCHECK(!has_pending_handshake_);
     has_pending_handshake_ = true;
     // TODO(jar): Be sure to use the highest priority for the crypto stream,
     // perhaps by adding a "special" priority for it that is higher than
     // kHighestPriority.
     priority = kHighestPriority;
   }
-  write_blocked_streams_.PushBack(id, priority);
+  write_blocked_streams_.PushBack(id, priority, connection()->version());
 }
 
 bool QuicSession::HasQueuedData() const {
-  return write_blocked_streams_.NumBlockedStreams() ||
+  return write_blocked_streams_.HasWriteBlockedStreams() ||
       connection_->HasQueuedData();
 }
 
 void QuicSession::MarkDecompressionBlocked(QuicHeaderId header_id,
                                            QuicStreamId stream_id) {
   DCHECK_GE(QUIC_VERSION_12, connection()->version());
   decompression_blocked_streams_[header_id] = stream_id;
 }
 
 bool QuicSession::GetSSLInfo(SSLInfo* ssl_info) {
   NOTIMPLEMENTED();
   return false;
 }
 
 void QuicSession::PostProcessAfterData() {
   STLDeleteElements(&closed_streams_);
   closed_streams_.clear();
 }
 
 }  // namespace net