net: Use stl utilities from the base namespace

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 "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "net/quic/core/crypto/proof_verifier.h"
@@ skipping 39 matching lines @@
 
 void QuicSession::Initialize() {
   connection_->set_visitor(this);
   connection_->SetFromConfig(config_);
 
   DCHECK_EQ(kCryptoStreamId, GetCryptoStream()->id());
   static_stream_map_[kCryptoStreamId] = GetCryptoStream();
 }
 
 QuicSession::~QuicSession() {
-  STLDeleteElements(&closed_streams_);
-  STLDeleteValues(&dynamic_stream_map_);
+  base::STLDeleteElements(&closed_streams_);
+  base::STLDeleteValues(&dynamic_stream_map_);
 
   DLOG_IF(WARNING, num_locally_closed_incoming_streams_highest_offset() >
                        max_open_incoming_streams_)
       << "Surprisingly high number of locally closed peer initiated streams"
          "still waiting for final byte offset: "
       << num_locally_closed_incoming_streams_highest_offset();
   DLOG_IF(WARNING, GetNumLocallyClosedOutgoingStreamsHighestOffset() >
                        max_open_outgoing_streams_)
       << "Surprisingly high number of locally closed self initiated streams"
          "still waiting for final byte offset: "
@@ skipping 11 matching lines @@
     if (frame.fin) {
       QuicStreamOffset final_byte_offset = frame.offset + frame.data_length;
       UpdateFlowControlOnFinalReceivedByteOffset(stream_id, final_byte_offset);
     }
     return;
   }
   stream->OnStreamFrame(frame);
 }
 
 void QuicSession::OnRstStream(const QuicRstStreamFrame& frame) {
-  if (ContainsKey(static_stream_map_, frame.stream_id)) {
+  if (base::ContainsKey(static_stream_map_, frame.stream_id)) {
     connection()->CloseConnection(
         QUIC_INVALID_STREAM_ID, "Attempt to reset a static stream",
         ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
     return;
   }
 
   ReliableQuicStream* stream = GetOrCreateDynamicStream(frame.stream_id);
   if (!stream) {
     HandleRstOnValidNonexistentStream(frame);
     return;  // Errors are handled by GetOrCreateStream.
@@ skipping 159 matching lines @@
   }
   QuicConsumedData data =
       connection_->SendStreamData(id, iov, offset, fin, 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)) {
+  if (base::ContainsKey(static_stream_map_, id)) {
     QUIC_BUG << "Cannot send RST for a static stream with ID " << id;
     return;
   }
 
   if (connection()->connected()) {
     // Only send a RST_STREAM frame if still connected.
     connection_->SendRstStream(id, error, bytes_written);
   }
   CloseStreamInner(id, true);
 }
@@ skipping 244 matching lines @@
 void QuicSession::OnCryptoHandshakeMessageReceived(
     const CryptoHandshakeMessage& /*message*/) {}
 
 QuicConfig* QuicSession::config() {
   return &config_;
 }
 
 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()));
+  DCHECK(!base::ContainsKey(dynamic_stream_map_, stream->id()));
+  DCHECK(!base::ContainsKey(static_stream_map_, stream->id()));
   dynamic_stream_map_[stream->id()] = stream;
   if (IsIncomingStream(stream->id())) {
     ++num_dynamic_incoming_streams_;
   }
   // Increase the number of streams being emulated when a new one is opened.
   connection_->SetNumOpenStreams(dynamic_stream_map_.size());
 }
 
 QuicStreamId QuicSession::GetNextOutgoingStreamId() {
   QuicStreamId id = next_outgoing_stream_id_;
   next_outgoing_stream_id_ += 2;
   return id;
 }
 
 ReliableQuicStream* QuicSession::GetOrCreateStream(
     const QuicStreamId stream_id) {
   StaticStreamMap::iterator it = static_stream_map_.find(stream_id);
   if (it != static_stream_map_.end()) {
     return it->second;
   }
   return GetOrCreateDynamicStream(stream_id);
 }
 
 void QuicSession::StreamDraining(QuicStreamId stream_id) {
-  DCHECK(ContainsKey(dynamic_stream_map_, stream_id));
-  if (!ContainsKey(draining_streams_, stream_id)) {
+  DCHECK(base::ContainsKey(dynamic_stream_map_, stream_id));
+  if (!base::ContainsKey(draining_streams_, stream_id)) {
     draining_streams_.insert(stream_id);
     if (IsIncomingStream(stream_id)) {
       ++num_draining_incoming_streams_;
     }
   }
 }
 
 bool QuicSession::MaybeIncreaseLargestPeerStreamId(
     const QuicStreamId stream_id) {
   if (stream_id <= largest_peer_created_stream_id_) {
@@ skipping 31 matching lines @@
 
 bool QuicSession::ShouldYield(QuicStreamId stream_id) {
   if (stream_id == currently_writing_stream_id_) {
     return false;
   }
   return write_blocked_streams()->ShouldYield(stream_id);
 }
 
 ReliableQuicStream* QuicSession::GetOrCreateDynamicStream(
     const QuicStreamId stream_id) {
-  DCHECK(!ContainsKey(static_stream_map_, stream_id))
+  DCHECK(!base::ContainsKey(static_stream_map_, stream_id))
       << "Attempt to call GetOrCreateDynamicStream for a static stream";
 
   DynamicStreamMap::iterator it = dynamic_stream_map_.find(stream_id);
   if (it != dynamic_stream_map_.end()) {
     return it->second;
   }
 
   if (IsClosedStream(stream_id)) {
     return nullptr;
   }
@@ skipping 48 matching lines @@
     // Stream is active
     return false;
   }
   if (!IsIncomingStream(id)) {
     // 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);
+         !base::ContainsKey(available_streams_, id);
 }
 
 bool QuicSession::IsOpenStream(QuicStreamId id) {
   DCHECK_NE(0u, id);
-  if (ContainsKey(static_stream_map_, id) ||
-      ContainsKey(dynamic_stream_map_, id)) {
+  if (base::ContainsKey(static_stream_map_, id) ||
+      base::ContainsKey(dynamic_stream_map_, id)) {
     // Stream is active
     return true;
   }
   return false;
 }
 
 size_t QuicSession::GetNumOpenIncomingStreams() const {
   return num_dynamic_incoming_streams_ - num_draining_incoming_streams_ +
          num_locally_closed_incoming_streams_highest_offset_;
 }
@@ skipping 18 matching lines @@
   write_blocked_streams_.AddStream(id);
 }
 
 bool QuicSession::HasDataToWrite() const {
   return write_blocked_streams_.HasWriteBlockedCryptoOrHeadersStream() ||
          write_blocked_streams_.HasWriteBlockedDataStreams() ||
          connection_->HasQueuedData();
 }
 
 void QuicSession::PostProcessAfterData() {
-  STLDeleteElements(&closed_streams_);
+  base::STLDeleteElements(&closed_streams_);
   closed_streams_.clear();
 }
 
 size_t QuicSession::GetNumDynamicOutgoingStreams() const {
   return dynamic_stream_map_.size() - num_dynamic_incoming_streams_;
 }
 
 size_t QuicSession::GetNumDrainingOutgoingStreams() const {
   return draining_streams_.size() - num_draining_incoming_streams_;
 }
@@ skipping 23 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;
 }
 
 }  // namespace net