Remove using namespace in net/quic/quic_stream_sequencer.h

net/quic/quic_stream_sequencer.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_stream_sequencer.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/logging.h"
@@ skipping 80 matching lines @@
       data.Consume(bytes_consumed);
       byte_offset += bytes_consumed;
     }
   }
 
   // Buffer any remaining data to be consumed by the stream when ready.
   for (size_t i = 0; i < data.Size(); ++i) {
     DVLOG(1) << "Buffering stream data at offset " << byte_offset;
     const iovec& iov = data.iovec()[i];
     buffered_frames_.insert(make_pair(
-        byte_offset, string(static_cast<char*>(iov.iov_base), iov.iov_len)));
+        byte_offset,
+        std::string(static_cast<char*>(iov.iov_base), iov.iov_len)));
     byte_offset += iov.iov_len;
     num_bytes_buffered_ += iov.iov_len;
   }
   return;
 }
 
 void QuicStreamSequencer::CloseStreamAtOffset(QuicStreamOffset offset) {
   const QuicStreamOffset kMaxOffset = numeric_limits<QuicStreamOffset>::max();
 
   // If we have a scheduled termination or close, any new offset should match
@@ skipping 142 matching lines @@
 
 void QuicStreamSequencer::SetBlockedUntilFlush() {
   blocked_ = true;
 }
 
 void QuicStreamSequencer::FlushBufferedFrames() {
   blocked_ = false;
   FrameMap::iterator it = buffered_frames_.find(num_bytes_consumed_);
   while (it != buffered_frames_.end()) {
     DVLOG(1) << "Flushing buffered packet at offset " << it->first;
-    string* data = &it->second;
+    std::string* data = &it->second;
     size_t bytes_consumed = stream_->ProcessRawData(data->c_str(),
                                                     data->size());
     RecordBytesConsumed(bytes_consumed);
     if (MaybeCloseStream()) {
       return;
     }
     if (bytes_consumed > data->size()) {
       stream_->Reset(QUIC_ERROR_PROCESSING_STREAM);  // Programming error
       return;
     } else if (bytes_consumed == data->size()) {
       buffered_frames_.erase(it);
       it = buffered_frames_.find(num_bytes_consumed_);
     } else {
-      string new_data = it->second.substr(bytes_consumed);
+      std::string new_data = it->second.substr(bytes_consumed);
       buffered_frames_.erase(it);
       buffered_frames_.insert(make_pair(num_bytes_consumed_, new_data));
       return;
     }
   }
   MaybeCloseStream();
 }
 
 void QuicStreamSequencer::RecordBytesConsumed(size_t bytes_consumed) {
   num_bytes_consumed_ += bytes_consumed;
   num_bytes_buffered_ -= bytes_consumed;
 
   stream_->AddBytesConsumed(bytes_consumed);
 }
 
 }  // namespace net