adds std:: to stl types (#049)

net/quic/core/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/core/quic_stream_sequencer.h"
 
 #include <algorithm>
 #include <cstdint>
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "net/base/ip_endpoint.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/core/quic_utils.h"
 #include "net/quic/core/reliable_quic_stream.h"
 #include "net/quic/test_tools/mock_clock.h"
 #include "net/quic/test_tools/quic_stream_sequencer_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/test/gtest_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gmock_mutant.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::StringPiece;
-using std::map;
 using std::min;
-using std::pair;
 using std::string;
-using std::vector;
 using testing::_;
 using testing::AnyNumber;
 using testing::CreateFunctor;
 using testing::InSequence;
 using testing::Return;
 using testing::StrEq;
 
 namespace net {
 namespace test {
 
@@ skipping 37 matching lines @@
  protected:
   QuicStreamSequencerTest()
       : connection_(new MockQuicConnection(&helper_,
                                            &alarm_factory_,
                                            Perspective::IS_CLIENT)),
         session_(connection_),
         stream_(&session_, 1),
         sequencer_(new QuicStreamSequencer(&stream_, &clock_)) {}
 
   // Verify that the data in first region match with the expected[0].
-  bool VerifyReadableRegion(const vector<string>& expected) {
+  bool VerifyReadableRegion(const std::vector<string>& expected) {
     iovec iovecs[1];
     if (sequencer_->GetReadableRegions(iovecs, 1)) {
-      return (VerifyIovecs(iovecs, 1, vector<string>{expected[0]}));
+      return (VerifyIovecs(iovecs, 1, std::vector<string>{expected[0]}));
     }
     return false;
   }
 
   // Verify that the data in each of currently readable regions match with each
   // item given in |expected|.
-  bool VerifyReadableRegions(const vector<string>& expected) {
+  bool VerifyReadableRegions(const std::vector<string>& expected) {
     iovec iovecs[5];
     size_t num_iovecs =
         sequencer_->GetReadableRegions(iovecs, arraysize(iovecs));
     return VerifyReadableRegion(expected) &&
            VerifyIovecs(iovecs, num_iovecs, expected);
   }
 
   bool VerifyIovecs(iovec* iovecs,
                     size_t num_iovecs,
-                    const vector<string>& expected) {
+                    const std::vector<string>& expected) {
     int start_position = 0;
     for (size_t i = 0; i < num_iovecs; ++i) {
       if (!VerifyIovec(iovecs[i],
                        expected[0].substr(start_position, iovecs[i].iov_len))) {
         return false;
       }
       start_position += iovecs[i].iov_len;
     }
     return true;
   }
@@ skipping 262 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 vector<Frame> FrameList;
+  typedef std::pair<int, string> Frame;
+  typedef std::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(std::make_pair(index, string(kPayload + index, size)));
       remaining_payload -= size;
     }
@@ skipping 92 matching lines @@
   EXPECT_CALL(stream_, OnDataAvailable());
 
   OnFrame(0, "abc");
   OnFrame(3, "def");
   OnFrame(6, "ghi");
 
   // abcdefghi buffered.
   EXPECT_EQ(9u, sequencer_->NumBytesBuffered());
 
   // Peek into the data.
-  vector<string> expected = {"abcdefghi"};
+  std::vector<string> expected = {"abcdefghi"};
   ASSERT_TRUE(VerifyReadableRegions(expected));
 
   // Consume 1 byte.
   sequencer_->MarkConsumed(1);
   EXPECT_EQ(1u, stream_.flow_controller()->bytes_consumed());
   // Verify data.
-  vector<string> expected2 = {"bcdefghi"};
+  std::vector<string> expected2 = {"bcdefghi"};
   ASSERT_TRUE(VerifyReadableRegions(expected2));
   EXPECT_EQ(8u, sequencer_->NumBytesBuffered());
 
   // Consume 2 bytes.
   sequencer_->MarkConsumed(2);
   EXPECT_EQ(3u, stream_.flow_controller()->bytes_consumed());
   // Verify data.
-  vector<string> expected3 = {"defghi"};
+  std::vector<string> expected3 = {"defghi"};
   ASSERT_TRUE(VerifyReadableRegions(expected3));
   EXPECT_EQ(6u, sequencer_->NumBytesBuffered());
 
   // Consume 5 bytes.
   sequencer_->MarkConsumed(5);
   EXPECT_EQ(8u, stream_.flow_controller()->bytes_consumed());
   // Verify data.
-  vector<string> expected4{"i"};
+  std::vector<string> expected4{"i"};
   ASSERT_TRUE(VerifyReadableRegions(expected4));
   EXPECT_EQ(1u, sequencer_->NumBytesBuffered());
 }
 
 TEST_F(QuicStreamSequencerTest, MarkConsumedError) {
   EXPECT_CALL(stream_, OnDataAvailable());
 
   OnFrame(0, "abc");
   OnFrame(9, "jklmnopqrstuvwxyz");
 
   // Peek into the data.  Only the first chunk should be readable because of the
   // missing data.
-  vector<string> expected{"abc"};
+  std::vector<string> expected{"abc"};
   ASSERT_TRUE(VerifyReadableRegions(expected));
 
   // Now, attempt to mark consumed more data than was readable and expect the
   // stream to be closed.
   EXPECT_CALL(stream_, Reset(QUIC_ERROR_PROCESSING_STREAM));
   EXPECT_QUIC_BUG(sequencer_->MarkConsumed(4),
                   "Invalid argument to MarkConsumed."
                   " expect to consume: 4, but not enough bytes available.");
 }
 
 TEST_F(QuicStreamSequencerTest, MarkConsumedWithMissingPacket) {
   InSequence s;
   EXPECT_CALL(stream_, OnDataAvailable());
 
   OnFrame(0, "abc");
   OnFrame(3, "def");
   // Missing packet: 6, ghi.
   OnFrame(9, "jkl");
 
-  vector<string> expected = {"abcdef"};
+  std::vector<string> expected = {"abcdef"};
   ASSERT_TRUE(VerifyReadableRegions(expected));
 
   sequencer_->MarkConsumed(6);
 }
 
 TEST_F(QuicStreamSequencerTest, DontAcceptOverlappingFrames) {
   // The peer should never send us non-identical stream frames which contain
   // overlapping byte ranges - if they do, we close the connection.
 
   QuicStreamFrame frame1(kClientDataStreamId1, false, 1, StringPiece("hello"));
@@ skipping 110 matching lines @@
   // Pass in a null iovec, expect to tear down connection.
   EXPECT_CALL(stream_, CloseConnectionWithDetails(
                            QUIC_STREAM_SEQUENCER_INVALID_STATE, _));
   iovec iov{nullptr, 512};
   sequencer_->Readv(&iov, 1u);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net