Remove using namespace in net/quic/quic_stream_sequencer.h

net/quic/quic_stream_sequencer_test.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 <string>
 #include <utility>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "net/base/ip_endpoint.h"
 #include "net/quic/quic_utils.h"
 #include "net/quic/reliable_quic_stream.h"
 #include "net/quic/test_tools/quic_stream_sequencer_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
@@ skipping 17 matching lines @@
 
 class MockStream : public ReliableQuicStream {
  public:
   MockStream(QuicSession* session, QuicStreamId id)
       : ReliableQuicStream(id, session) {
   }
 
   MOCK_METHOD0(OnFinRead, void());
   MOCK_METHOD2(ProcessRawData, uint32(const char* data, uint32 data_len));
   MOCK_METHOD2(CloseConnectionWithDetails, void(QuicErrorCode error,
-                                                const string& details));
+                                                const std::string& details));
   MOCK_METHOD1(Reset, void(QuicRstStreamErrorCode error));
   MOCK_METHOD0(OnCanWrite, void());
   QuicPriority EffectivePriority() const override {
     return QuicUtils::HighestPriority();
   }
   virtual bool IsFlowControlEnabled() const {
     return true;
   }
 };
 
@@ skipping 66 matching lines @@
     frame.offset = byte_offset;
     frame.data.Append(const_cast<char*>(data), strlen(data));
     frame.fin = false;
     sequencer_->OnStreamFrame(frame);
   }
 
   MockConnection* connection_;
   MockSession session_;
   testing::StrictMock<MockStream> stream_;
   scoped_ptr<QuicStreamSequencer> sequencer_;
-  map<QuicStreamOffset, string>* buffered_frames_;
+  map<QuicStreamOffset, std::string>* buffered_frames_;
 };
 
 TEST_F(QuicStreamSequencerTest, RejectOldFrame) {
   EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(3));
 
   OnFrame(0, "abc");
   EXPECT_EQ(0u, buffered_frames_->size());
   EXPECT_EQ(3u, sequencer_->num_bytes_consumed());
   // Ignore this - it matches a past sequence number and we should not see it
   // again.
@@ skipping 177 matching lines @@
   EXPECT_CALL(stream_, Reset(QUIC_MULTIPLE_TERMINATION_OFFSETS));
   OnFinFrame(1, "");
   EXPECT_EQ(3u, QuicStreamSequencerPeer::GetCloseOffset(sequencer_.get()));
 
   OnFinFrame(3, "");
   EXPECT_EQ(3u, QuicStreamSequencerPeer::GetCloseOffset(sequencer_.get()));
 }
 
 class QuicSequencerRandomTest : public QuicStreamSequencerTest {
  public:
-  typedef pair<int, string> Frame;
+  typedef pair<int, std::string> Frame;
   typedef vector<Frame> FrameList;
 
   void CreateFrames() {
     int payload_size = arraysize(kPayload) - 1;
     int remaining_payload = payload_size;
     while (remaining_payload != 0) {
       int size = min(OneToN(6), remaining_payload);
       int index = payload_size - remaining_payload;
-      list_.push_back(make_pair(index, string(kPayload + index, size)));
+      list_.push_back(make_pair(index, std::string(kPayload + index, size)));
       remaining_payload -= size;
     }
   }
 
   QuicSequencerRandomTest() {
     CreateFrames();
   }
 
   int OneToN(int n) {
     return base::RandInt(1, n);
   }
 
   int MaybeProcessMaybeBuffer(const char* data, uint32 len) {
     int to_process = len;
     if (base::RandUint64() % 2 != 0) {
       to_process = base::RandInt(0, len);
     }
     output_.append(data, to_process);
     return to_process;
   }
 
-  string output_;
+  std::string output_;
   FrameList list_;
 };
 
 // All frames are processed as soon as we have sequential data.
 // Infinite buffering, so all frames are acked right away.
 TEST_F(QuicSequencerRandomTest, RandomFramesNoDroppingNoBackup) {
   InSequence s;
   for (size_t i = 0; i < list_.size(); ++i) {
-    string* data = &list_[i].second;
+    std::string* data = &list_[i].second;
     EXPECT_CALL(stream_, ProcessRawData(StrEq(*data), data->size()))
         .WillOnce(Return(data->size()));
   }
 
   while (!list_.empty()) {
     int index = OneToN(list_.size()) - 1;
     LOG(ERROR) << "Sending index " << index << " " << list_[index].second;
     OnFrame(list_[index].first, list_[index].second.data());
 
     list_.erase(list_.begin() + index);
   }
 }
 
 TEST_F(QuicStreamSequencerTest, FrameOverlapsBufferedData) {
   // Ensure that FrameOverlapsBufferedData returns appropriate responses when
   // there is existing data buffered.
 
-  map<QuicStreamOffset, string>* buffered_frames =
+  map<QuicStreamOffset, std::string>* buffered_frames =
       QuicStreamSequencerPeer::GetBufferedFrames(sequencer_.get());
 
   const int kBufferedOffset = 10;
   const int kBufferedDataLength = 3;
   const int kNewDataLength = 3;
-  IOVector data = MakeIOVector(string(kNewDataLength, '.'));
+  IOVector data = MakeIOVector(std::string(kNewDataLength, '.'));
 
   // No overlap if no buffered frames.
   EXPECT_TRUE(buffered_frames_->empty());
   EXPECT_FALSE(sequencer_->FrameOverlapsBufferedData(
       QuicStreamFrame(1, false, kBufferedOffset - 1, data)));
 
   // Add a buffered frame.
   buffered_frames->insert(
-      make_pair(kBufferedOffset, string(kBufferedDataLength, '.')));
+      make_pair(kBufferedOffset, std::string(kBufferedDataLength, '.')));
 
   // New byte range partially overlaps with buffered frame, start offset
   // preceeding buffered frame.
   EXPECT_TRUE(sequencer_->FrameOverlapsBufferedData(
       QuicStreamFrame(1, false, kBufferedOffset - 1, data)));
   EXPECT_TRUE(sequencer_->FrameOverlapsBufferedData(
       QuicStreamFrame(1, false, kBufferedOffset - kNewDataLength + 1, data)));
 
   // New byte range partially overlaps with buffered frame, start offset
   // inside existing buffered frame.
@@ skipping 23 matching lines @@
   QuicStreamFrame frame2(kClientDataStreamId1, false, 2, MakeIOVector("hello"));
   EXPECT_TRUE(sequencer_->FrameOverlapsBufferedData(frame2));
   EXPECT_CALL(stream_, CloseConnectionWithDetails(QUIC_INVALID_STREAM_FRAME, _))
       .Times(1);
   sequencer_->OnStreamFrame(frame2);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net