diff --git a/quic/core/http/quic_spdy_client_session_base.cc b/quic/core/http/quic_spdy_client_session_base.cc
index 9bb2ee2..ba5a9cc 100644
--- a/quic/core/http/quic_spdy_client_session_base.cc
+++ b/quic/core/http/quic_spdy_client_session_base.cc
@@ -171,8 +171,8 @@
 
 QuicSpdyStream* QuicSpdyClientSessionBase::GetPromisedStream(
     const QuicStreamId id) {
-  DynamicStreamMap::iterator it = dynamic_streams().find(id);
-  if (it != dynamic_streams().end()) {
+  StreamMap::iterator it = stream_map().find(id);
+  if (it != stream_map().end()) {
     return static_cast<QuicSpdyStream*>(it->second.get());
   }
   return nullptr;
diff --git a/quic/core/http/quic_spdy_session.cc b/quic/core/http/quic_spdy_session.cc
index 701a4c5..3fe1f5c 100644
--- a/quic/core/http/quic_spdy_session.cc
+++ b/quic/core/http/quic_spdy_session.cc
@@ -343,7 +343,7 @@
   for (auto const& kv : zombie_streams()) {
     static_cast<QuicSpdyStream*>(kv.second.get())->ClearSession();
   }
-  for (auto const& kv : dynamic_streams()) {
+  for (auto const& kv : stream_map()) {
     if (!kv.second->is_static()) {
       static_cast<QuicSpdyStream*>(kv.second.get())->ClearSession();
     }
@@ -743,11 +743,11 @@
 
 bool QuicSpdySession::HasActiveRequestStreams() const {
   // In the case where session is destructed by calling
-  // dynamic_streams().clear(), we will have incorrect accounting here.
+  // stream_map().clear(), we will have incorrect accounting here.
   // TODO(renjietang): Modify destructors and make this a DCHECK.
-  if (static_cast<size_t>(dynamic_streams().size()) >
+  if (static_cast<size_t>(stream_map().size()) >
       num_incoming_static_streams() + num_outgoing_static_streams()) {
-    return dynamic_streams().size() - num_incoming_static_streams() -
+    return stream_map().size() - num_incoming_static_streams() -
                num_outgoing_static_streams() >
            0;
   }
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index 5e6cbd4..750f256 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -121,7 +121,7 @@
                                        bool stream_already_counted) {
   DCHECK(stream->is_static());
   QuicStreamId stream_id = stream->id();
-  dynamic_stream_map_[stream_id] = std::move(stream);
+  stream_map_[stream_id] = std::move(stream);
   if (VersionHasIetfQuicFrames(connection_->transport_version())) {
     v99_streamid_manager_.RegisterStaticStream(stream_id,
                                                stream_already_counted);
@@ -174,7 +174,7 @@
       QuicUtils::GetStreamType(stream_id, perspective(),
                                IsIncomingStream(stream_id)) ==
           READ_UNIDIRECTIONAL &&
-      dynamic_stream_map_.find(stream_id) == dynamic_stream_map_.end()) {
+      stream_map_.find(stream_id) == stream_map_.end()) {
     PendingStreamOnStreamFrame(frame);
     return;
   }
@@ -252,8 +252,8 @@
     return true;  // Continue processing the packet.
   }
   // If stream is non-existent, close the connection
-  DynamicStreamMap::iterator it = dynamic_stream_map_.find(stream_id);
-  if (it == dynamic_stream_map_.end()) {
+  StreamMap::iterator it = stream_map_.find(stream_id);
+  if (it == stream_map_.end()) {
     QUIC_DVLOG(1) << ENDPOINT
                   << "Received STOP_SENDING for non-existent stream, id: "
                   << stream_id << " Closing connection";
@@ -333,7 +333,7 @@
       QuicUtils::GetStreamType(stream_id, perspective(),
                                IsIncomingStream(stream_id)) ==
           READ_UNIDIRECTIONAL &&
-      dynamic_stream_map_.find(stream_id) == dynamic_stream_map_.end()) {
+      stream_map_.find(stream_id) == stream_map_.end()) {
     PendingStreamOnRstStream(frame);
     return;
   }
@@ -391,7 +391,7 @@
 
   // Copy all non static streams in a new map for the ease of deleting.
   QuicSmallMap<QuicStreamId, QuicStream*, 10> non_static_streams;
-  for (const auto& it : dynamic_stream_map_) {
+  for (const auto& it : stream_map_) {
     if (!it.second->is_static()) {
       non_static_streams[it.first] = it.second.get();
     }
@@ -399,7 +399,7 @@
   for (const auto& it : non_static_streams) {
     QuicStreamId id = it.first;
     it.second->OnConnectionClosed(frame.quic_error_code, source);
-    if (dynamic_stream_map_.find(id) != dynamic_stream_map_.end()) {
+    if (stream_map_.find(id) != stream_map_.end()) {
       QUIC_BUG << ENDPOINT << "Stream " << id
                << " failed to close under OnConnectionClosed";
       CloseStream(id);
@@ -635,7 +635,7 @@
 }
 
 uint64_t QuicSession::GetNumOpenDynamicStreams() const {
-  return dynamic_stream_map_.size() - draining_streams_.size() +
+  return stream_map_.size() - draining_streams_.size() +
          locally_closed_streams_highest_offset_.size() -
          num_incoming_static_streams_ - num_outgoing_static_streams_;
 }
@@ -726,8 +726,8 @@
   }
   DCHECK(VersionHasIetfQuicFrames(connection_->transport_version()));
 
-  DynamicStreamMap::iterator it = dynamic_stream_map_.find(id);
-  if (it != dynamic_stream_map_.end()) {
+  StreamMap::iterator it = stream_map_.find(id);
+  if (it != stream_map_.end()) {
     if (it->second->is_static()) {
       QUIC_DVLOG(1) << ENDPOINT
                     << "Try to send rst for a static stream, id: " << id
@@ -793,8 +793,8 @@
 void QuicSession::CloseStreamInner(QuicStreamId stream_id, bool locally_reset) {
   QUIC_DVLOG(1) << ENDPOINT << "Closing stream " << stream_id;
 
-  DynamicStreamMap::iterator it = dynamic_stream_map_.find(stream_id);
-  if (it == dynamic_stream_map_.end()) {
+  StreamMap::iterator it = stream_map_.find(stream_id);
+  if (it == stream_map_.end()) {
     // When CloseStreamInner has been called recursively (via
     // QuicStream::OnClose), the stream will already have been deleted
     // from stream_map_, so return immediately.
@@ -844,7 +844,7 @@
     InsertLocallyClosedStreamsHighestOffset(
         stream_id, stream->flow_controller()->highest_received_byte_offset());
   }
-  dynamic_stream_map_.erase(it);
+  stream_map_.erase(it);
   if (IsIncomingStream(stream_id)) {
     --num_dynamic_incoming_streams_;
   }
@@ -1049,7 +1049,7 @@
   config_.SetInitialSessionFlowControlWindowToSend(session_window);
   flow_controller_.UpdateReceiveWindowSize(session_window);
   // Inform all existing streams about the new window.
-  for (auto const& kv : dynamic_stream_map_) {
+  for (auto const& kv : stream_map_) {
     kv.second->flow_controller()->UpdateReceiveWindowSize(stream_window);
   }
   if (!QuicVersionUsesCryptoFrames(connection_->transport_version())) {
@@ -1095,7 +1095,7 @@
   }
 
   // Inform all existing streams about the new window.
-  for (auto const& kv : dynamic_stream_map_) {
+  for (auto const& kv : stream_map_) {
     kv.second->UpdateSendWindowOffset(new_window);
   }
   if (!QuicVersionUsesCryptoFrames(connection_->transport_version())) {
@@ -1179,10 +1179,10 @@
 void QuicSession::ActivateStream(std::unique_ptr<QuicStream> stream) {
   DCHECK(!stream->is_static());
   QuicStreamId stream_id = stream->id();
-  QUIC_DVLOG(1) << ENDPOINT << "num_streams: " << dynamic_stream_map_.size()
+  QUIC_DVLOG(1) << ENDPOINT << "num_streams: " << stream_map_.size()
                 << ". activating " << stream_id;
-  DCHECK(!QuicContainsKey(dynamic_stream_map_, stream_id));
-  dynamic_stream_map_[stream_id] = std::move(stream);
+  DCHECK(!QuicContainsKey(stream_map_, stream_id));
+  stream_map_[stream_id] = std::move(stream);
   if (IsIncomingStream(stream_id)) {
     ++num_dynamic_incoming_streams_;
   }
@@ -1228,7 +1228,7 @@
 }
 
 void QuicSession::StreamDraining(QuicStreamId stream_id) {
-  DCHECK(QuicContainsKey(dynamic_stream_map_, stream_id));
+  DCHECK(QuicContainsKey(stream_map_, stream_id));
   if (!QuicContainsKey(draining_streams_, stream_id)) {
     draining_streams_.insert(stream_id);
     if (IsIncomingStream(stream_id)) {
@@ -1278,9 +1278,8 @@
 
 QuicStream* QuicSession::GetOrCreateDynamicStream(
     const QuicStreamId stream_id) {
-
-  DynamicStreamMap::iterator it = dynamic_stream_map_.find(stream_id);
-  if (it != dynamic_stream_map_.end()) {
+  StreamMap::iterator it = stream_map_.find(stream_id);
+  if (it != stream_map_.end()) {
     return it->second.get();
   }
 
@@ -1345,7 +1344,7 @@
 bool QuicSession::IsOpenStream(QuicStreamId id) {
   DCHECK_NE(QuicUtils::GetInvalidStreamId(connection_->transport_version()),
             id);
-  if (QuicContainsKey(dynamic_stream_map_, id) ||
+  if (QuicContainsKey(stream_map_, id) ||
       QuicContainsKey(pending_stream_map_, id) ||
       QuicUtils::IsCryptoStreamId(connection_->transport_version(), id)) {
     // Stream is active
@@ -1355,8 +1354,8 @@
 }
 
 bool QuicSession::IsStaticStream(QuicStreamId id) const {
-  auto it = dynamic_stream_map_.find(id);
-  if (it == dynamic_stream_map_.end()) {
+  auto it = stream_map_.find(id);
+  if (it == stream_map_.end()) {
     return false;
   }
   return it->second->is_static();
@@ -1377,7 +1376,7 @@
 }
 
 size_t QuicSession::GetNumActiveStreams() const {
-  return dynamic_stream_map_.size() - draining_streams_.size() -
+  return stream_map_.size() - draining_streams_.size() -
          num_incoming_static_streams_ - num_outgoing_static_streams_;
 }
 
@@ -1411,11 +1410,11 @@
 }
 
 size_t QuicSession::GetNumDynamicOutgoingStreams() const {
-  DCHECK_GE(static_cast<size_t>(dynamic_stream_map_.size() +
-                                pending_stream_map_.size()),
-            num_dynamic_incoming_streams_ + num_outgoing_static_streams_ +
-                num_incoming_static_streams_);
-  return dynamic_stream_map_.size() + pending_stream_map_.size() -
+  DCHECK_GE(
+      static_cast<size_t>(stream_map_.size() + pending_stream_map_.size()),
+      num_dynamic_incoming_streams_ + num_outgoing_static_streams_ +
+          num_incoming_static_streams_);
+  return stream_map_.size() + pending_stream_map_.size() -
          num_dynamic_incoming_streams_ - num_outgoing_static_streams_ -
          num_incoming_static_streams_;
 }
@@ -1437,7 +1436,7 @@
 }
 
 bool QuicSession::IsStreamFlowControlBlocked() {
-  for (auto const& kv : dynamic_stream_map_) {
+  for (auto const& kv : stream_map_) {
     if (kv.second->flow_controller()->IsBlocked()) {
       return true;
     }
@@ -1508,10 +1507,10 @@
 
   // The number of the streams waiting for acks should not be larger than the
   // number of streams.
-  if (static_cast<size_t>(dynamic_stream_map_.size() + zombie_streams_.size()) <
+  if (static_cast<size_t>(stream_map_.size() + zombie_streams_.size()) <
       streams_waiting_for_acks_.size()) {
     QUIC_BUG << "More streams are waiting for acks than the number of streams. "
-             << "Sizes: dynamic streams: " << dynamic_stream_map_.size()
+             << "Sizes: streams: " << stream_map_.size()
              << ", zombie streams: " << zombie_streams_.size()
              << ", vs streams waiting for acks: "
              << streams_waiting_for_acks_.size();
@@ -1519,8 +1518,8 @@
 }
 
 QuicStream* QuicSession::GetStream(QuicStreamId id) const {
-  auto active_stream = dynamic_stream_map_.find(id);
-  if (active_stream != dynamic_stream_map_.end()) {
+  auto active_stream = stream_map_.find(id);
+  if (active_stream != stream_map_.end()) {
     return active_stream->second.get();
   }
   auto zombie_stream = zombie_streams_.find(id);
diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
index 6bb31e1..5ef497d 100644
--- a/quic/core/quic_session.h
+++ b/quic/core/quic_session.h
@@ -366,8 +366,8 @@
   size_t MaxAvailableBidirectionalStreams() const;
   size_t MaxAvailableUnidirectionalStreams() const;
 
-  // Returns existing static or dynamic stream with id = |stream_id|. If no
-  // such stream exists, and |stream_id| is a peer-created dynamic stream id,
+  // Returns existing stream with id = |stream_id|. If no
+  // such stream exists, and |stream_id| is a peer-created stream id,
   // then a new stream is created and returned. In all other cases, nullptr is
   // returned.
   QuicStream* GetOrCreateStream(const QuicStreamId stream_id);
@@ -429,8 +429,7 @@
   }
 
  protected:
-  using DynamicStreamMap =
-      QuicSmallMap<QuicStreamId, std::unique_ptr<QuicStream>, 10>;
+  using StreamMap = QuicSmallMap<QuicStreamId, std::unique_ptr<QuicStream>, 10>;
 
   using PendingStreamMap =
       QuicSmallMap<QuicStreamId, std::unique_ptr<PendingStream>, 10>;
@@ -452,7 +451,7 @@
   // Return the reserved crypto stream as a constant pointer.
   virtual const QuicCryptoStream* GetCryptoStream() const = 0;
 
-  // Adds |stream| to the dynamic stream map.
+  // Adds |stream| to the stream map.
   virtual void ActivateStream(std::unique_ptr<QuicStream> stream);
 
   // Returns the stream ID for a new outgoing bidirectional/unidirectional
@@ -496,17 +495,15 @@
   // ProcessPendingStream().
   virtual bool UsesPendingStreams() const { return false; }
 
-  // Transfer ownership of |stream| to dynamic_stream_map_, and register
+  // Transfer ownership of |stream| to stream_map_, and register
   // |stream| as static in stream id manager. |stream_already_counted| is true
   // if |stream| is created from pending stream and is already known as an open
   // stream.
   void RegisterStaticStream(std::unique_ptr<QuicStream> stream,
                             bool stream_already_counted);
 
-  DynamicStreamMap& dynamic_streams() { return dynamic_stream_map_; }
-  const DynamicStreamMap& dynamic_streams() const {
-    return dynamic_stream_map_;
-  }
+  StreamMap& stream_map() { return stream_map_; }
+  const StreamMap& stream_map() const { return stream_map_; }
 
   ClosedStreams* closed_streams() { return &closed_streams_; }
 
@@ -641,7 +638,7 @@
   QuicConfig config_;
 
   // Map from StreamId to pointers to streams. Owns the streams.
-  DynamicStreamMap dynamic_stream_map_;
+  StreamMap stream_map_;
 
   // Map from StreamId to PendingStreams for peer-created unidirectional streams
   // which are waiting for the first byte of payload to arrive.
@@ -663,18 +660,18 @@
   // Manages stream IDs for version99/IETF QUIC
   UberQuicStreamIdManager v99_streamid_manager_;
 
-  // A counter for peer initiated streams which are in the dynamic_stream_map_.
+  // A counter for peer initiated dynamic streams which are in the stream_map_.
   size_t num_dynamic_incoming_streams_;
 
   // A counter for peer initiated streams which are in the draining_streams_.
   size_t num_draining_incoming_streams_;
 
   // A counter for self initiated static streams which are in
-  // dynamic_stream_map_.
+  // stream_map_.
   size_t num_outgoing_static_streams_;
 
   // A counter for peer initiated static streams which are in
-  // dynamic_stream_map_.
+  // stream_map_.
   size_t num_incoming_static_streams_;
 
   // A counter for peer initiated streams which are in the
diff --git a/quic/test_tools/quic_session_peer.cc b/quic/test_tools/quic_session_peer.cc
index 018d35a..0dfba43 100644
--- a/quic/test_tools/quic_session_peer.cc
+++ b/quic/test_tools/quic_session_peer.cc
@@ -130,9 +130,8 @@
 }
 
 // static
-QuicSession::DynamicStreamMap& QuicSessionPeer::dynamic_streams(
-    QuicSession* session) {
-  return session->dynamic_streams();
+QuicSession::StreamMap& QuicSessionPeer::stream_map(QuicSession* session) {
+  return session->stream_map();
 }
 
 // static
@@ -173,7 +172,7 @@
 
 // static
 bool QuicSessionPeer::IsStreamCreated(QuicSession* session, QuicStreamId id) {
-  return QuicContainsKey(session->dynamic_streams(), id);
+  return QuicContainsKey(session->stream_map(), id);
 }
 
 // static
diff --git a/quic/test_tools/quic_session_peer.h b/quic/test_tools/quic_session_peer.h
index f414f19..9ca8530 100644
--- a/quic/test_tools/quic_session_peer.h
+++ b/quic/test_tools/quic_session_peer.h
@@ -56,7 +56,7 @@
                                               QuicStreamId stream_id);
   static std::map<QuicStreamId, QuicStreamOffset>&
   GetLocallyClosedStreamsHighestOffset(QuicSession* session);
-  static QuicSession::DynamicStreamMap& dynamic_streams(QuicSession* session);
+  static QuicSession::StreamMap& stream_map(QuicSession* session);
   static const QuicSession::ClosedStreams& closed_streams(QuicSession* session);
   static QuicSession::ZombieStreamMap& zombie_streams(QuicSession* session);
   static QuicUnorderedSet<QuicStreamId>* GetDrainingStreams(
diff --git a/quic/test_tools/quic_spdy_session_peer.cc b/quic/test_tools/quic_spdy_session_peer.cc
index affdbd6..be0849b 100644
--- a/quic/test_tools/quic_spdy_session_peer.cc
+++ b/quic/test_tools/quic_spdy_session_peer.cc
@@ -19,7 +19,7 @@
 void QuicSpdySessionPeer::SetUnownedHeadersStream(
     QuicSpdySession* session,
     QuicHeadersStream* headers_stream) {
-  for (auto& it : session->dynamic_streams()) {
+  for (auto& it : session->stream_map()) {
     if (it.first == QuicUtils::GetHeadersStreamId(
                         session->connection()->transport_version())) {
       it.second.reset(headers_stream);