Remove using namespace in net/quic/quic_stream_sequencer.h

net/quic/quic_data_stream_test.cc

Index: net/quic/quic_data_stream_test.cc
diff --git a/net/quic/quic_data_stream_test.cc b/net/quic/quic_data_stream_test.cc
index 16e63410c2250ae169308a57cc76c500c5f79a5e..fe2efbb2ee039987a1fd813c1cec28478ab93d93 100644
--- a/net/quic/quic_data_stream_test.cc
+++ b/net/quic/quic_data_stream_test.cc
@@ -4,6 +4,8 @@
 
 #include "net/quic/quic_data_stream.h"
 
+#include <string>
+
 #include "net/quic/quic_ack_notifier.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_utils.h"
@@ -43,7 +45,7 @@ class TestStream : public QuicDataStream {
   uint32 ProcessData(const char* data, uint32 data_len) override {
     EXPECT_NE(0u, data_len);
     DVLOG(1) << "ProcessData data_len: " << data_len;
-    data_ += string(data, data_len);
+    data_ += std::string(data, data_len);
     return should_process_data_ ? data_len : 0;
   }
 
@@ -51,11 +53,11 @@ class TestStream : public QuicDataStream {
   using ReliableQuicStream::CloseReadSide;
   using ReliableQuicStream::CloseWriteSide;
 
-  const string& data() const { return data_; }
+  const std::string& data() const { return data_; }
 
  private:
   bool should_process_data_;
-  string data_;
+  std::string data_;
 };
 
 class QuicDataStreamTest : public ::testing::TestWithParam<QuicVersion> {
@@ -117,7 +119,7 @@ INSTANTIATE_TEST_CASE_P(Tests, QuicDataStreamTest,
 TEST_P(QuicDataStreamTest, ProcessHeaders) {
   Initialize(kShouldProcessData);
 
-  string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
+  std::string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
   stream_->OnStreamHeadersPriority(QuicUtils::HighestPriority());
   stream_->OnStreamHeaders(headers);
   EXPECT_EQ(headers, stream_->data());
@@ -130,8 +132,8 @@ TEST_P(QuicDataStreamTest, ProcessHeaders) {
 TEST_P(QuicDataStreamTest, ProcessHeadersAndBody) {
   Initialize(kShouldProcessData);
 
-  string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
-  string body = "this is the body";
+  std::string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
+  std::string body = "this is the body";
 
   stream_->OnStreamHeaders(headers);
   EXPECT_EQ(headers, stream_->data());
@@ -143,8 +145,8 @@ TEST_P(QuicDataStreamTest, ProcessHeadersAndBody) {
 }
 
 TEST_P(QuicDataStreamTest, ProcessHeadersAndBodyFragments) {
-  string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
-  string body = "this is the body";
+  std::string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
+  std::string body = "this is the body";
 
   for (size_t fragment_size = 1; fragment_size < body.size();
        ++fragment_size) {
@@ -171,8 +173,8 @@ TEST_P(QuicDataStreamTest, ProcessHeadersAndBodyFragments) {
 }
 
 TEST_P(QuicDataStreamTest, ProcessHeadersAndBodyFragmentsSplit) {
-  string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
-  string body = "this is the body";
+  std::string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
+  std::string body = "this is the body";
 
   for (size_t split_point = 1; split_point < body.size() - 1; ++split_point) {
     Initialize(kShouldProcessData);
@@ -203,8 +205,8 @@ TEST_P(QuicDataStreamTest, ProcessHeadersAndBodyFragmentsSplit) {
 TEST_P(QuicDataStreamTest, ProcessHeadersAndBodyReadv) {
   Initialize(!kShouldProcessData);
 
-  string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
-  string body = "this is the body";
+  std::string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
+  std::string body = "this is the body";
 
   stream_->OnStreamHeaders(headers);
   EXPECT_EQ(headers, stream_->data());
@@ -220,18 +222,18 @@ TEST_P(QuicDataStreamTest, ProcessHeadersAndBodyReadv) {
 
   size_t bytes_read = stream_->Readv(&vec, 1);
   EXPECT_EQ(headers.length(), bytes_read);
-  EXPECT_EQ(headers, string(buffer, bytes_read));
+  EXPECT_EQ(headers, std::string(buffer, bytes_read));
 
   bytes_read = stream_->Readv(&vec, 1);
   EXPECT_EQ(body.length(), bytes_read);
-  EXPECT_EQ(body, string(buffer, bytes_read));
+  EXPECT_EQ(body, std::string(buffer, bytes_read));
 }
 
 TEST_P(QuicDataStreamTest, ProcessHeadersAndBodyIncrementalReadv) {
   Initialize(!kShouldProcessData);
 
-  string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
-  string body = "this is the body";
+  std::string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
+  std::string body = "this is the body";
   stream_->OnStreamHeaders(headers);
   EXPECT_EQ(headers, stream_->data());
   stream_->OnStreamHeadersComplete(false, headers.size());
@@ -243,7 +245,7 @@ TEST_P(QuicDataStreamTest, ProcessHeadersAndBodyIncrementalReadv) {
   vec.iov_base = buffer;
   vec.iov_len = arraysize(buffer);
 
-  string data = headers + body;
+  std::string data = headers + body;
   for (size_t i = 0; i < data.length(); ++i) {
     size_t bytes_read = stream_->Readv(&vec, 1);
     ASSERT_EQ(1u, bytes_read);
@@ -254,8 +256,8 @@ TEST_P(QuicDataStreamTest, ProcessHeadersAndBodyIncrementalReadv) {
 TEST_P(QuicDataStreamTest, ProcessHeadersUsingReadvWithMultipleIovecs) {
   Initialize(!kShouldProcessData);
 
-  string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
-  string body = "this is the body";
+  std::string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
+  std::string body = "this is the body";
   stream_->OnStreamHeaders(headers);
   EXPECT_EQ(headers, stream_->data());
   stream_->OnStreamHeadersComplete(false, headers.size());
@@ -269,7 +271,7 @@ TEST_P(QuicDataStreamTest, ProcessHeadersUsingReadvWithMultipleIovecs) {
   vec[0].iov_len = arraysize(buffer1);
   vec[1].iov_base = buffer2;
   vec[1].iov_len = arraysize(buffer2);
-  string data = headers + body;
+  std::string data = headers + body;
   for (size_t i = 0; i < data.length(); i += 2) {
     size_t bytes_read = stream_->Readv(vec, 2);
     ASSERT_EQ(2u, bytes_read) << i;
@@ -291,8 +293,8 @@ TEST_P(QuicDataStreamTest, StreamFlowControlBlocked) {
                          stream_->flow_controller()));
 
   // Try to send more data than the flow control limit allows.
-  string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
-  string body;
+  std::string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
+  std::string body;
   const uint64 kOverflow = 15;
   GenerateBody(&body, kWindow + kOverflow);
 
@@ -332,8 +334,8 @@ TEST_P(QuicDataStreamTest, StreamFlowControlNoWindowUpdateIfNotConsumed) {
                          stream_->flow_controller()));
 
   // Stream receives enough data to fill a fraction of the receive window.
-  string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
-  string body;
+  std::string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
+  std::string body;
   GenerateBody(&body, kWindow / 3);
   stream_->OnStreamHeaders(headers);
   EXPECT_EQ(headers, stream_->data());
@@ -371,8 +373,8 @@ TEST_P(QuicDataStreamTest, StreamFlowControlWindowUpdate) {
                          stream_->flow_controller()));
 
   // Stream receives enough data to fill a fraction of the receive window.
-  string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
-  string body;
+  std::string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
+  std::string body;
   GenerateBody(&body, kWindow / 3);
   stream_->OnStreamHeaders(headers);
   EXPECT_EQ(headers, stream_->data());
@@ -421,7 +423,7 @@ TEST_P(QuicDataStreamTest, ConnectionFlowControlWindowUpdate) {
                                               kWindow);
 
   // Supply headers to both streams so that they are happy to receive data.
-  string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
+  std::string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
   stream_->OnStreamHeaders(headers);
   stream_->OnStreamHeadersComplete(false, headers.size());
   stream2_->OnStreamHeaders(headers);
@@ -429,7 +431,7 @@ TEST_P(QuicDataStreamTest, ConnectionFlowControlWindowUpdate) {
 
   // Each stream gets a quarter window of data. This should not trigger a
   // WINDOW_UPDATE for either stream, nor for the connection.
-  string body;
+  std::string body;
   GenerateBody(&body, kWindow / 4);
   QuicStreamFrame frame1(kClientDataStreamId1, false, 0, MakeIOVector(body));
   stream_->OnStreamFrame(frame1);
@@ -463,13 +465,13 @@ TEST_P(QuicDataStreamTest, StreamFlowControlViolation) {
   QuicFlowControllerPeer::SetReceiveWindowOffset(stream_->flow_controller(),
                                                  kWindow);
 
-  string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
+  std::string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
   stream_->OnStreamHeaders(headers);
   EXPECT_EQ(headers, stream_->data());
   stream_->OnStreamHeadersComplete(false, headers.size());
 
   // Receive data to overflow the window, violating flow control.
-  string body;
+  std::string body;
   GenerateBody(&body, kWindow + 1);
   QuicStreamFrame frame(kClientDataStreamId1, false, 0, MakeIOVector(body));
   EXPECT_CALL(*connection_,
@@ -494,13 +496,13 @@ TEST_P(QuicDataStreamTest, ConnectionFlowControlViolation) {
   QuicFlowControllerPeer::SetReceiveWindowOffset(session_->flow_controller(),
                                                  kConnectionWindow);
 
-  string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
+  std::string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
   stream_->OnStreamHeaders(headers);
   EXPECT_EQ(headers, stream_->data());
   stream_->OnStreamHeadersComplete(false, headers.size());
 
   // Send enough data to overflow the connection level flow control window.
-  string body;
+  std::string body;
   GenerateBody(&body, kConnectionWindow + 1);
   EXPECT_LT(body.size(),  kStreamWindow);
   QuicStreamFrame frame(kClientDataStreamId1, false, 0, MakeIOVector(body));
@@ -522,7 +524,7 @@ TEST_P(QuicDataStreamTest, StreamFlowControlFinNotBlocked) {
                     stream_->flow_controller()));
 
   // Send a frame with a FIN but no data. This should not be blocked.
-  string body = "";
+  std::string body = "";
   bool fin = true;
 
   EXPECT_CALL(*connection_, SendBlocked(kClientDataStreamId1)).Times(0);