Landing Recent QUIC changes until and including Mon Nov 16 14:15:48 2015

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/ssl/ssl_info.h"
 
 using base::StringPiece;
 using base::hash_map;
 using base::hash_set;
 using std::make_pair;
 using std::map;
 using std::max;
 using std::string;
 using std::vector;
+using net::SpdyPriority;
 
 namespace net {
 
 #define ENDPOINT \
   (perspective() == Perspective::IS_SERVER ? "Server: " : " Client: ")
 
 // We want to make sure we delete any closed streams in a safe manner.
 // To avoid deleting a stream in mid-operation, we have a simple shim between
 // us and the stream, so we can delete any streams when we return from
 // processing.
@@ skipping 73 matching lines @@
       max_open_streams_(config_.MaxStreamsPerConnection()),
       next_outgoing_stream_id_(perspective() == Perspective::IS_SERVER ? 2 : 3),
       largest_peer_created_stream_id_(
           perspective() == Perspective::IS_SERVER ? 1 : 0),
       error_(QUIC_NO_ERROR),
       flow_controller_(connection_.get(),
                        0,
                        perspective(),
                        kMinimumFlowControlSendWindow,
                        config_.GetInitialSessionFlowControlWindowToSend(),
-                       false),
-      has_pending_handshake_(false) {}
+                       false) {}
 
 void QuicSession::Initialize() {
   connection_->set_visitor(visitor_shim_.get());
   connection_->SetFromConfig(config_);
 
   DCHECK_EQ(kCryptoStreamId, GetCryptoStream()->id());
   static_stream_map_[kCryptoStreamId] = GetCryptoStream();
 }
 
 QuicSession::~QuicSession() {
@@ skipping 124 matching lines @@
           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 != nullptr && !stream->flow_controller()->IsBlocked()) {
-      // If the stream can't write all bytes, it'll re-add itself to the blocked
+      // If the stream can't write all bytes it'll re-add itself to the blocked
       // list.
       stream->OnCanWrite();
     }
   }
 }
 
 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_;
+  return write_blocked_streams_.crypto_stream_blocked();
 }
 
 bool QuicSession::HasOpenDynamicStreams() const {
   return GetNumOpenStreams() > 0;
 }
 
 QuicConsumedData QuicSession::WritevData(
     QuicStreamId id,
     QuicIOVector iov,
     QuicStreamOffset offset,
     bool fin,
     FecProtection fec_protection,
     QuicAckListenerInterface* ack_notifier_delegate) {
-  return connection_->SendStreamData(id, iov, offset, fin, fec_protection,
-                                     ack_notifier_delegate);
+  QuicConsumedData data = connection_->SendStreamData(
+      id, iov, offset, fin, fec_protection, ack_notifier_delegate);
+  write_blocked_streams_.UpdateBytesForStream(id, data.bytes_consumed);
+  return data;
 }
 
 void QuicSession::SendRstStream(QuicStreamId id,
                                 QuicRstStreamErrorCode error,
                                 QuicStreamOffset bytes_written) {
   if (ContainsKey(static_stream_map_, id)) {
     LOG(DFATAL) << "Cannot send RST for a static stream with ID " << id;
     return;
   }
 
@@ skipping 395 matching lines @@
     // Locally created streams are strictly in-order.  If the id is in the
     // range of created streams and it's not active, it must have been closed.
     return id < next_outgoing_stream_id_;
   }
   // For peer created streams, we also need to consider available streams.
   return id <= largest_peer_created_stream_id_ &&
          !ContainsKey(available_streams_, id);
 }
 
 size_t QuicSession::GetNumOpenStreams() const {
-  if (FLAGS_quic_count_unfinished_as_open_streams) {
-    if (FLAGS_allow_many_available_streams) {
-      return dynamic_stream_map_.size() - draining_streams_.size() +
-             locally_closed_streams_highest_offset_.size();
-    } else {
-      return dynamic_stream_map_.size() + available_streams_.size() -
-             draining_streams_.size() +
-             locally_closed_streams_highest_offset_.size();
-    }
+  if (FLAGS_allow_many_available_streams) {
+    return dynamic_stream_map_.size() - draining_streams_.size() +
+           locally_closed_streams_highest_offset_.size();
   } else {
-    if (FLAGS_allow_many_available_streams) {
-      return dynamic_stream_map_.size() - draining_streams_.size();
-    } else {
-      return dynamic_stream_map_.size() + available_streams_.size() -
-             draining_streams_.size();
-    }
+    return dynamic_stream_map_.size() + available_streams_.size() -
+           draining_streams_.size() +
+           locally_closed_streams_highest_offset_.size();
   }
 }
 
 size_t QuicSession::GetNumActiveStreams() const {
-  if (FLAGS_quic_count_unfinished_as_open_streams) {
-    return GetNumOpenStreams() - locally_closed_streams_highest_offset_.size();
-  } else {
-    return GetNumOpenStreams();
-  }
+  return GetNumOpenStreams() - locally_closed_streams_highest_offset_.size();
 }
 
 size_t QuicSession::GetNumAvailableStreams() const {
   return available_streams_.size();
 }
 
 void QuicSession::MarkConnectionLevelWriteBlocked(QuicStreamId id,
-                                                  QuicPriority priority) {
+                                                  SpdyPriority priority) {
 #ifndef NDEBUG
   ReliableQuicStream* stream = GetStream(id);
   if (stream != nullptr) {
-    LOG_IF(DFATAL, priority != stream->EffectivePriority())
+    LOG_IF(DFATAL, priority != stream->Priority())
         << ENDPOINT << "Stream " << id
-        << "Priorities do not match.  Got: " << priority
-        << " Expected: " << stream->EffectivePriority();
+        << "Priorities do not match.  Got: " << static_cast<int>(priority)
+        << " Expected: " << static_cast<int>(stream->Priority());
   } else {
     LOG(DFATAL) << "Marking unknown stream " << id << " blocked.";
   }
 #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_.AddStream(id, priority);
 }
 
 bool QuicSession::HasDataToWrite() const {
   return write_blocked_streams_.HasWriteBlockedCryptoOrHeadersStream() ||
          write_blocked_streams_.HasWriteBlockedDataStreams() ||
          connection_->HasQueuedData();
 }
 
 void QuicSession::PostProcessAfterData() {
   STLDeleteElements(&closed_streams_);
-
-  // A buggy client may fail to send FIN/RSTs. Don't tolerate this.
-  if (!FLAGS_quic_count_unfinished_as_open_streams &&
-      locally_closed_streams_highest_offset_.size() > max_open_streams_) {
-    CloseConnection(QUIC_TOO_MANY_UNFINISHED_STREAMS);
-  }
+  closed_streams_.clear();
 }
 
 bool QuicSession::IsConnectionFlowControlBlocked() const {
   return flow_controller_.IsBlocked();
 }
 
 bool QuicSession::IsStreamFlowControlBlocked() {
   for (auto const& kv : static_stream_map_) {
     if (kv.second->flow_controller()->IsBlocked()) {
       return true;
     }
   }
   for (auto const& kv : dynamic_stream_map_) {
     if (kv.second->flow_controller()->IsBlocked()) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace net