Don't set QUIC's write alarm if we are connection flow control blocked.

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_flags.h"
@@ skipping 61 matching lines @@
   virtual void OnConnectionClosed(
       QuicErrorCode error, bool from_peer) OVERRIDE {
     session_->OnConnectionClosed(error, from_peer);
     // The session will go away, so don't bother with cleanup.
   }
 
   virtual void OnWriteBlocked() OVERRIDE {
     session_->OnWriteBlocked();
   }
 
-  virtual bool HasPendingWrites() const OVERRIDE {
-    return session_->HasPendingWrites();
+  virtual bool WillingAndAbleToWrite() const OVERRIDE {
+    return session_->WillingAndAbleToWrite();
   }
 
   virtual bool HasPendingHandshake() const OVERRIDE {
     return session_->HasPendingHandshake();
   }
 
   virtual bool HasOpenDataStreams() const OVERRIDE {
     return session_->HasOpenDataStreams();
   }
 
@@ skipping 174 matching lines @@
     // TODO(rjshade): Compare our flow control receive windows for specified
     //                streams: if we have a large window then maybe something
     //                had gone wrong with the flow control accounting.
     DVLOG(1) << ENDPOINT << "Received BLOCKED frame with stream id: "
              << frames[i].stream_id;
   }
 }
 
 void QuicSession::OnCanWrite() {
   // We limit the number of writes to the number of pending streams. If more
-  // streams become pending, HasPendingWrites will be true, which will cause
-  // the connection to request resumption before yielding to other connections.
+  // streams become pending, WillingAndAbleToWrite will be true, which will
+  // cause the connection to request resumption before yielding to other
+  // connections.
   size_t num_writes = write_blocked_streams_.NumBlockedStreams();
+  if (flow_controller_->IsBlocked()) {
+    // If we are connection level flow control blocked, then only allow the
+    // crypto and headers streams to try writing as all other streams will be
+    // blocked.
+    num_writes = 0;
+    if (write_blocked_streams_.crypto_stream_blocked()) {
+      num_writes += 1;
+    }
+    if (write_blocked_streams_.headers_stream_blocked()) {
+      num_writes += 1;
+    }
+  }
   if (num_writes == 0) {
     return;
   }
 
   QuicConnection::ScopedPacketBundler ack_bundler(
       connection_.get(), QuicConnection::NO_ACK);
   for (size_t i = 0; i < num_writes; ++i) {
-    if (!write_blocked_streams_.HasWriteBlockedStreams()) {
+    if (!(write_blocked_streams_.HasWriteBlockedCryptoOrHeadersStream() ||
+          write_blocked_streams_.HasWriteBlockedDataStreams())) {
       // Writing one stream removed another!? Something's broken.
       LOG(DFATAL) << "WriteBlockedStream is missing";
       connection_->CloseConnection(QUIC_INTERNAL_ERROR, false);
       return;
     }
     if (!connection_->CanWriteStreamData()) {
       return;
     }
     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 && !stream->flow_controller()->IsBlocked()) {
       // If the stream can't write all bytes, it'll re-add itself to the blocked
       // list.
       stream->OnCanWrite();
     }
   }
 }
 
-bool QuicSession::HasPendingWrites() const {
-  return write_blocked_streams_.HasWriteBlockedStreams();
+bool QuicSession::WillingAndAbleToWrite() const {
+  // If the crypto or headers streams are blocked, we want to schedule a write -
+  // they don't get blocked by connection level flow control. Otherwise only
+  // schedule a write if we are not flow control blocked at the connection
+  // level.
+  return write_blocked_streams_.HasWriteBlockedCryptoOrHeadersStream() ||
+         (!flow_controller_->IsBlocked() &&
+          write_blocked_streams_.HasWriteBlockedDataStreams());
 }
 
 bool QuicSession::HasPendingHandshake() const {
   return has_pending_handshake_;
 }
 
 bool QuicSession::HasOpenDataStreams() const {
   return GetNumOpenStreams() > 0;
 }
 
@@ skipping 275 matching lines @@
     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);
 }
 
 bool QuicSession::HasDataToWrite() const {
-  return write_blocked_streams_.HasWriteBlockedStreams() ||
-      connection_->HasQueuedData();
+  return write_blocked_streams_.HasWriteBlockedCryptoOrHeadersStream() ||
+         write_blocked_streams_.HasWriteBlockedDataStreams() ||
+         connection_->HasQueuedData();
 }
 
 bool QuicSession::GetSSLInfo(SSLInfo* ssl_info) const {
   NOTIMPLEMENTED();
   return false;
 }
 
 void QuicSession::PostProcessAfterData() {
   STLDeleteElements(&closed_streams_);
   closed_streams_.clear();
 }
 
 void QuicSession::OnSuccessfulVersionNegotiation(const QuicVersion& version) {
   if (version < QUIC_VERSION_19) {
     flow_controller_->Disable();
   }
 }
 
 }  // namespace net