Rename GetNextStreamId to GetNextOutgoingStreamId in QuicSession.

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 85 matching lines @@
 
  private:
   QuicSession* session_;
 };
 
 QuicSession::QuicSession(QuicConnection* connection, const QuicConfig& config)
     : connection_(connection),
       visitor_shim_(new VisitorShim(this)),
       config_(config),
       max_open_streams_(config_.MaxStreamsPerConnection()),
-      next_stream_id_(perspective() == Perspective::IS_SERVER ? 2 : 3),
+      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) {
-}
+      has_pending_handshake_(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 36 matching lines @@
     // update the connection level flow controller if needed.
     UpdateFlowControlOnFinalReceivedByteOffset(frame.stream_id,
                                                frame.byte_offset);
     return;  // Errors are handled by GetStream.
   }
 
   stream->OnStreamReset(frame);
 }
 
 void QuicSession::OnGoAway(const QuicGoAwayFrame& frame) {
-  DCHECK(frame.last_good_stream_id < next_stream_id_);
+  DCHECK(frame.last_good_stream_id < next_outgoing_stream_id_);
 }
 
 void QuicSession::OnConnectionClosed(QuicErrorCode error, bool from_peer) {
   DCHECK(!connection_->connected());
   if (error_ == QUIC_NO_ERROR) {
     error_ = error;
   }
 
   while (!dynamic_stream_map_.empty()) {
     StreamMap::iterator it = dynamic_stream_map_.begin();
@@ skipping 368 matching lines @@
 void QuicSession::ActivateStream(ReliableQuicStream* stream) {
   DVLOG(1) << ENDPOINT << "num_streams: " << dynamic_stream_map_.size()
            << ". activating " << stream->id();
   DCHECK(!ContainsKey(dynamic_stream_map_, stream->id()));
   DCHECK(!ContainsKey(static_stream_map_, stream->id()));
   dynamic_stream_map_[stream->id()] = stream;
   // Increase the number of streams being emulated when a new one is opened.
   connection_->SetNumOpenStreams(dynamic_stream_map_.size());
 }
 
-QuicStreamId QuicSession::GetNextStreamId() {
-  QuicStreamId id = next_stream_id_;
-  next_stream_id_ += 2;
+QuicStreamId QuicSession::GetNextOutgoingStreamId() {
+  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);
 }
@@ skipping 20 matching lines @@
 
   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_stream_id_ % 2) {
+  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);
     return nullptr;
   }
 
   return GetIncomingDynamicStream(stream_id);
 }
 
 ReliableQuicStream* QuicSession::GetIncomingDynamicStream(
@@ skipping 94 matching lines @@
   return connection_->goaway_received();
 }
 
 bool QuicSession::IsClosedStream(QuicStreamId id) {
   DCHECK_NE(0u, id);
   if (ContainsKey(static_stream_map_, id) ||
       ContainsKey(dynamic_stream_map_, id)) {
     // Stream is active
     return false;
   }
-  if (id % 2 == next_stream_id_ % 2) {
+  if (id % 2 == next_outgoing_stream_id_ % 2) {
     // 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_stream_id_;
+    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_allow_many_available_streams) {
     return dynamic_stream_map_.size() - draining_streams_.size();
   } else {
@@ skipping 58 matching lines @@
   }
   for (auto const& kv : dynamic_stream_map_) {
     if (kv.second->flow_controller()->IsBlocked()) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace net