Landing Recent QUIC changes until: Fri Oct 30 22:23:58 2015 +0000

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 139 matching lines @@
   stream->OnStreamFrame(frame);
 }
 
 void QuicSession::OnRstStream(const QuicRstStreamFrame& frame) {
   if (ContainsKey(static_stream_map_, frame.stream_id)) {
     connection()->SendConnectionCloseWithDetails(
         QUIC_INVALID_STREAM_ID, "Attempt to reset a static stream");
     return;
   }
 
-  ReliableQuicStream* stream = GetDynamicStream(frame.stream_id);
+  ReliableQuicStream* stream = GetOrCreateDynamicStream(frame.stream_id);
   if (!stream) {
     // The RST frame contains the final byte offset for the stream: we can now
     // update the connection level flow controller if needed.
     UpdateFlowControlOnFinalReceivedByteOffset(frame.stream_id,
                                                frame.byte_offset);
     return;  // Errors are handled by GetStream.
   }
 
   stream->OnStreamReset(frame);
 }
@@ skipping 392 matching lines @@
   QuicStreamId id = next_outgoing_stream_id_;
   next_outgoing_stream_id_ += 2;
   return id;
 }
 
 ReliableQuicStream* QuicSession::GetStream(const QuicStreamId stream_id) {
   StreamMap::iterator it = static_stream_map_.find(stream_id);
   if (it != static_stream_map_.end()) {
     return it->second;
   }
-  return GetDynamicStream(stream_id);
+  return GetOrCreateDynamicStream(stream_id);
 }
 
 void QuicSession::StreamDraining(QuicStreamId stream_id) {
   DCHECK(ContainsKey(dynamic_stream_map_, stream_id));
   if (!ContainsKey(draining_streams_, stream_id)) {
     draining_streams_.insert(stream_id);
   }
 }
 
 void QuicSession::CloseConnection(QuicErrorCode error) {
   if (connection()->connected()) {
     connection()->SendConnectionClose(error);
   }
 }
 
-ReliableQuicStream* QuicSession::GetDynamicStream(
+ReliableQuicStream* QuicSession::GetOrCreateDynamicStream(
     const QuicStreamId stream_id) {
-  if (static_stream_map_.find(stream_id) != static_stream_map_.end()) {
-    DLOG(FATAL) << "Attempt to call GetDynamicStream for a static stream";
+  if (ContainsKey(static_stream_map_, stream_id)) {
+    DLOG(FATAL)
+        << "Attempt to call GetOrCreateDynamicStream for a static stream";
     return nullptr;
   }
 
   StreamMap::iterator it = dynamic_stream_map_.find(stream_id);
   if (it != dynamic_stream_map_.end()) {
     return it->second;
   }
 
   if (IsClosedStream(stream_id)) {
     return nullptr;
   }
 
   if (stream_id % 2 == next_outgoing_stream_id_ % 2) {
-    // We've received a frame for a locally-created stream that is not
-    // currently active.  This is an error.
-    CloseConnection(QUIC_PACKET_FOR_NONEXISTENT_STREAM);
+    // Received a frame for a locally-created stream that is not currently
+    // active. This is an error.
+    CloseConnection(QUIC_INVALID_STREAM_ID);
     return nullptr;
   }
 
-  return GetIncomingDynamicStream(stream_id);
-}
-
-ReliableQuicStream* QuicSession::GetIncomingDynamicStream(
-    QuicStreamId stream_id) {
-  if (IsClosedStream(stream_id)) {
-    return nullptr;
-  }
   available_streams_.erase(stream_id);
 
-  // Legitimate streams created by the peer are alternately-numbered.
-  if (FLAGS_allow_many_available_streams &&
-      stream_id % 2 != largest_peer_created_stream_id_ % 2) {
-    // Close the connection.
-    DVLOG(1) << "Invalid incoming stream_id " << stream_id;
-    connection()->SendConnectionClose(QUIC_INVALID_STREAM_ID);
-    return nullptr;
-  }
-
   if (stream_id > largest_peer_created_stream_id_) {
     if (FLAGS_allow_many_available_streams) {
       // Check if the new number of available streams would cause the number of
       // available streams to exceed the limit.  Note that the peer can create
       // only alternately-numbered streams.
       size_t additional_available_streams =
           (stream_id - largest_peer_created_stream_id_) / 2 - 1;
       size_t new_num_available_streams =
           GetNumAvailableStreams() + additional_available_streams;
       if (new_num_available_streams > get_max_available_streams()) {
@@ skipping 171 matching lines @@
   }
   for (auto const& kv : dynamic_stream_map_) {
     if (kv.second->flow_controller()->IsBlocked()) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace net