Break out of the loop in QuicSession::OnCanWrite if the QuicConnection

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 255 matching lines @@
       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_.NumBlockedStreams();
 
-  while (!connection_->HasQueuedData() &&
-         remaining_writes > 0) {
+  while (remaining_writes > 0 && connection_->CanWriteStreamData()) {
     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.
     }
     QuicStreamId stream_id = write_blocked_streams_.PopFront();
     if (stream_id == kCryptoStreamId) {
       has_pending_handshake_ = false;  // We just popped it.
     }
@@ skipping 318 matching lines @@
     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, connection()->version());
 }
 
-bool QuicSession::HasQueuedData() const {
+bool QuicSession::HasDataToWrite() const {
   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