Remove using namespace in net/quic/quic_stream_sequencer.h

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_flow_controller.h"
@@ skipping 364 matching lines @@
 void QuicSession::SendRstStream(QuicStreamId id,
                                 QuicRstStreamErrorCode error,
                                 QuicStreamOffset bytes_written) {
   if (connection()->connected()) {
     // Only send a RST_STREAM frame if still connected.
     connection_->SendRstStream(id, error, bytes_written);
   }
   CloseStreamInner(id, true);
 }
 
-void QuicSession::SendGoAway(QuicErrorCode error_code, const string& reason) {
+void QuicSession::SendGoAway(QuicErrorCode error_code,
+                             const std::string& reason) {
   if (goaway_sent_) {
     return;
   }
   goaway_sent_ = true;
   connection_->SendGoAway(error_code, largest_peer_created_stream_id_, reason);
 }
 
 void QuicSession::CloseStream(QuicStreamId stream_id) {
   CloseStreamInner(stream_id, false);
 }
@@ skipping 26 matching lines @@
   }
 
   stream_map_.erase(it);
   stream->OnClose();
   // Decrease the number of streams being emulated when a new one is opened.
   connection_->SetNumOpenStreams(stream_map_.size());
 }
 
 void QuicSession::UpdateFlowControlOnFinalReceivedByteOffset(
     QuicStreamId stream_id, QuicStreamOffset final_byte_offset) {
-  map<QuicStreamId, QuicStreamOffset>::iterator it =
+  std::map<QuicStreamId, QuicStreamOffset>::iterator it =
       locally_closed_streams_highest_offset_.find(stream_id);
   if (it == locally_closed_streams_highest_offset_.end()) {
     return;
   }
 
   DVLOG(1) << ENDPOINT << "Received final byte offset " << final_byte_offset
            << " for stream " << stream_id;
   uint64 offset_diff = final_byte_offset - it->second;
   if (flow_controller_->UpdateHighestReceivedOffset(
       flow_controller_->highest_received_byte_offset() + offset_diff)) {
@@ skipping 332 matching lines @@
   for (DataStreamMap::iterator it = stream_map_.begin();
        it != stream_map_.end(); ++it) {
     if (it->second->flow_controller()->IsBlocked()) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace net