Landing Recent QUIC changes until Sat Apr 29 00:22:04 2017 +0000

net/quic/core/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/core/quic_session.h"
 
 #include <cstdint>
 #include <utility>
 
 #include "net/quic/core/quic_connection.h"
@@ skipping 26 matching lines @@
       num_draining_incoming_streams_(0),
       num_locally_closed_incoming_streams_highest_offset_(0),
       error_(QUIC_NO_ERROR),
       flow_controller_(connection_,
                        0,
                        perspective(),
                        kMinimumFlowControlSendWindow,
                        config_.GetInitialSessionFlowControlWindowToSend(),
                        perspective() == Perspective::IS_SERVER,
                        nullptr),
-      currently_writing_stream_id_(0) {}
+      currently_writing_stream_id_(0),
+      respect_goaway_(true) {}
 
 void QuicSession::Initialize() {
   connection_->set_visitor(this);
   connection_->SetFromConfig(config_);
 
   DCHECK_EQ(kCryptoStreamId, GetMutableCryptoStream()->id());
   static_stream_map_[kCryptoStreamId] = GetMutableCryptoStream();
 }
 
 QuicSession::~QuicSession() {
@@ skipping 655 matching lines @@
   if (!IsIncomingStream(stream_id)) {
     HandleFrameOnNonexistentOutgoingStream(stream_id);
     return nullptr;
   }
 
   available_streams_.erase(stream_id);
 
   if (!MaybeIncreaseLargestPeerStreamId(stream_id)) {
     return nullptr;
   }
+
+  if (FLAGS_quic_reloadable_flag_quic_refactor_stream_creation) {
+    return MaybeCreateIncomingDynamicStream(stream_id);
+  }
+
   // Check if the new number of open streams would cause the number of
   // open streams to exceed the limit.
   if (GetNumOpenIncomingStreams() >= max_open_incoming_streams()) {
     // Refuse to open the stream.
     SendRstStream(stream_id, QUIC_REFUSED_STREAM, 0);
     return nullptr;
   }
 
   return CreateIncomingDynamicStream(stream_id);
 }
@@ skipping 126 matching lines @@
 }
 
 size_t QuicSession::MaxAvailableStreams() const {
   return max_open_incoming_streams_ * kMaxAvailableStreamsMultiplier;
 }
 
 bool QuicSession::IsIncomingStream(QuicStreamId id) const {
   return id % 2 != next_outgoing_stream_id_ % 2;
 }
 
+bool QuicSession::ShouldCreateIncomingDynamicStream2(QuicStreamId id) {
+  DCHECK(FLAGS_quic_reloadable_flag_quic_refactor_stream_creation);
+  if (goaway_received() && respect_goaway_) {
+    QUIC_DLOG(INFO) << "Failed to create a new outgoing stream. "
+                    << "Already received goaway.";
+    return false;
+  }
+  if (!IsIncomingStream(id)) {
+    QUIC_DLOG(INFO) << "invalid incoming stream id: " << id;
+    return false;
+  }
+  if (!connection()->connected()) {
+    QUIC_DLOG(INFO)
+        << "ShouldCreateIncomingDynamicStream called when disconnected";
+    return false;
+  }
+  if (GetNumOpenIncomingStreams() >= max_open_incoming_streams()) {
+    DVLOG(1) << "Reset stream (refused) " << id;
+    SendRstStream(id, QUIC_REFUSED_STREAM, 0);
+    return false;
+  }
+
+  return true;
+}
+
+bool QuicSession::ShouldCreateOutgoingDynamicStream2() {
+  DCHECK(FLAGS_quic_reloadable_flag_quic_refactor_stream_creation);
+  if (!connection()->connected()) {
+    QUIC_DLOG(INFO)
+        << "ShouldCreateOutgoingDynamicStream called when disconnected";
+    return false;
+  }
+  if (!IsEncryptionEstablished()) {
+    QUIC_DLOG(INFO) << "Encryption not established so no outgoing stream "
+                    << "created.";
+    return false;
+  }
+  if (goaway_received() && respect_goaway_) {
+    QUIC_DLOG(INFO) << "Failed to create a new outgoing stream. "
+                    << "Already received goaway.";
+    return false;
+  }
+  if (GetNumOpenOutgoingStreams() >= max_open_outgoing_streams()) {
+    QUIC_DLOG(INFO) << "Failed to create a new outgoing stream. "
+                    << "Already " << GetNumOpenOutgoingStreams() << " open.";
+    return false;
+  }
+  return true;
+}
+
+QuicStream* QuicSession::MaybeCreateIncomingDynamicStream(QuicStreamId id) {
+  if (!ShouldCreateIncomingDynamicStream2(id)) {
+    return nullptr;
+  }
+  return CreateAndActivateStream(id);
+}
+
+QuicStream* QuicSession::MaybeCreateOutgoingDynamicStream(
+    SpdyPriority priority) {
+  if (!ShouldCreateOutgoingDynamicStream2()) {
+    return nullptr;
+  }
+  return CreateAndActivateStream(GetNextOutgoingStreamId());
+}
+
+QuicStream* QuicSession::CreateAndActivateStream(QuicStreamId id) {
+  std::unique_ptr<QuicStream> stream = CreateStream(id);
+  QuicStream* stream_ptr = stream.get();
+  ActivateStream(std::move(stream));
+  return stream_ptr;
+}
+
 }  // namespace net