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/quic/quic_flags.h"
+#include "net/quic/quic_flow_controller.h"
 #include "net/quic/quic_headers_stream.h"
 #include "net/ssl/ssl_info.h"
 
 using base::StringPiece;
 using base::hash_map;
 using base::hash_set;
 using std::make_pair;
 using std::vector;
 
 namespace net {
@@ skipping 50 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();
   }
 
  private:
   QuicSession* session_;
 };
 
 QuicSession::QuicSession(QuicConnection* connection,
+                         uint32 max_flow_control_receive_window_bytes,
                          const QuicConfig& config)
     : connection_(connection),
       visitor_shim_(new VisitorShim(this)),
       config_(config),
       max_open_streams_(config_.max_streams_per_connection()),
       next_stream_id_(is_server() ? 2 : 3),
       largest_peer_created_stream_id_(0),
       error_(QUIC_NO_ERROR),
       goaway_received_(false),
       goaway_sent_(false),
-      has_pending_handshake_(false) {
+      has_pending_handshake_(false),
+      max_flow_control_receive_window_bytes_(
+          max_flow_control_receive_window_bytes) {
+  if (max_flow_control_receive_window_bytes_ < kDefaultFlowControlSendWindow) {
+    LOG(ERROR) << "Initial receive window ("
+               << max_flow_control_receive_window_bytes_
+               << ") cannot be set lower than default ("
+               << kDefaultFlowControlSendWindow << ").";
+    max_flow_control_receive_window_bytes_ = kDefaultFlowControlSendWindow;
+  }
+  flow_controller_.reset(new QuicFlowController(
+      connection_->supported_versions().front(), 0, is_server(),
+      kDefaultFlowControlSendWindow, max_flow_control_receive_window_bytes_,
+      max_flow_control_receive_window_bytes_));
 
   connection_->set_visitor(visitor_shim_.get());
   connection_->SetFromConfig(config_);
   if (connection_->connected()) {
     connection_->SetOverallConnectionTimeout(
         config_.max_time_before_crypto_handshake());
   }
   headers_stream_.reset(new QuicHeadersStream(this));
   if (!is_server()) {
     // For version above QUIC v12, the headers stream is stream 3, so the
@@ skipping 103 matching lines @@
     // Stream may be closed by the time we receive a WINDOW_UPDATE, so we can't
     // assume that it still exists.
     QuicStreamId stream_id = frames[i].stream_id;
     if (stream_id == 0) {
       // This is a window update that applies to the connection, rather than an
       // individual stream.
       DVLOG(1) << ENDPOINT
                << "Received connection level flow control window update with "
                   "byte offset: " << frames[i].byte_offset;
       if (FLAGS_enable_quic_connection_flow_control &&
-          connection()->flow_controller()->UpdateSendWindowOffset(
-              frames[i].byte_offset)) {
+          flow_controller_->UpdateSendWindowOffset(frames[i].byte_offset)) {
         connection_window_updated = true;
       }
       continue;
     }
 
     QuicDataStream* stream = GetDataStream(stream_id);
     if (stream) {
       stream->OnWindowUpdateFrame(frames[i]);
     }
   }
@@ skipping 10 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())) {

[wtc, 2014/05/19 18:58:40]

Nit: I would simplify this expression with De Morgan's laws. Up to you.

[ramant (doing other things), 2014/05/20 03:22:32]

rjshade: wdyt?

       // 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 84 matching lines @@
       return;
     }
     DataStreamMap::iterator it = stream_map_.begin();
     while (it != stream_map_.end()) {
       it->second->flow_controller()->UpdateSendWindowOffset(
           new_flow_control_send_window);
       it++;
     }
 
     // Update connection level window.
-    connection()->flow_controller()->UpdateSendWindowOffset(
-        new_flow_control_send_window);
+    flow_controller_->UpdateSendWindowOffset(new_flow_control_send_window);
   }
 }
 
 void QuicSession::OnCryptoHandshakeEvent(CryptoHandshakeEvent event) {
   switch (event) {
     // TODO(satyamshekhar): Move the logic of setting the encrypter/decrypter
     // to QuicSession since it is the glue.
     case ENCRYPTION_FIRST_ESTABLISHED:
       break;
 
@@ skipping 170 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