Add SpdyString alias for std::string in net/spdy.

net/spdy/hpack/hpack_input_stream_test.cc

 // Copyright 2014 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/spdy/hpack/hpack_input_stream.h"
 
 #include <bitset>
-#include <string>
 #include <vector>
 
 #include "base/logging.h"
 #include "net/spdy/hpack/hpack_constants.h"
 #include "net/spdy/spdy_test_utils.h"
 #include "net/test/gtest_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace test {
 
-using std::string;
 using test::a2b_hex;
 
 // Hex representation of encoded length and Huffman string.
 const char kEncodedHuffmanFixture[] =
     "2d"  // Length prefix.
     "94e7821dd7f2e6c7b335dfdfcd5b3960"
     "d5af27087f3672c1ab270fb5291f9587"
     "316065c003ed4ee5b1063d5007";
 
 const char kDecodedHuffmanFixture[] =
@@ skipping 34 matching lines @@
 void ExpectDecodeUint32Invalid(uint8_t N, SpdyStringPiece str) {
   EXPECT_GT(N, 0);
   EXPECT_LE(N, 8);
   HpackInputStream input_stream(str);
   HpackInputStreamPeer input_stream_peer(&input_stream);
   input_stream_peer.SetBitOffsetForTest(8 - N);
   uint32_t I;
   EXPECT_FALSE(input_stream.DecodeNextUint32(&I));
 }
 
-uint32_t bits32(const string& bitstring) {
+uint32_t bits32(const SpdyString& bitstring) {
   return std::bitset<32>(bitstring).to_ulong();
 }
 
 // The {Number}ByteIntegersEightBitPrefix tests below test that
 // certain integers are decoded correctly with an 8-bit prefix in
 // exactly {Number} bytes.
 
 TEST(HpackInputStreamTest, OneByteIntegersEightBitPrefix) {
   // Minimum.
-  EXPECT_EQ(0x00u, DecodeValidUint32(8, string("\x00", 1)));
+  EXPECT_EQ(0x00u, DecodeValidUint32(8, SpdyString("\x00", 1)));
   EXPECT_EQ(0x7fu, DecodeValidUint32(8, "\x7f"));
   // Maximum.
   EXPECT_EQ(0xfeu, DecodeValidUint32(8, "\xfe"));
   // Invalid.
   ExpectDecodeUint32Invalid(8, "\xff");
 }
 
 TEST(HpackInputStreamTest, TwoByteIntegersEightBitPrefix) {
   // Minimum.
-  EXPECT_EQ(0xffu, DecodeValidUint32(8, string("\xff\x00", 2)));
+  EXPECT_EQ(0xffu, DecodeValidUint32(8, SpdyString("\xff\x00", 2)));
   EXPECT_EQ(0x0100u, DecodeValidUint32(8, "\xff\x01"));
   // Maximum.
   EXPECT_EQ(0x017eu, DecodeValidUint32(8, "\xff\x7f"));
   // Invalid.
   ExpectDecodeUint32Invalid(8, "\xff\x80");
   ExpectDecodeUint32Invalid(8, "\xff\xff");
 }
 
 TEST(HpackInputStreamTest, ThreeByteIntegersEightBitPrefix) {
   // Minimum.
@@ skipping 52 matching lines @@
   ExpectDecodeUint32Invalid(8, "\xff\x80\x80\x80\x80\x80\x01");
   ExpectDecodeUint32Invalid(8, "\xff\xff\xff\xff\xff\xff\xff");
 }
 
 // The {Number}ByteIntegersOneToSevenBitPrefix tests below test that
 // certain integers are encoded correctly with an N-bit prefix in
 // exactly {Number} bytes for N in {1, 2, ..., 7}.
 
 TEST(HpackInputStreamTest, OneByteIntegersOneToSevenBitPrefixes) {
   // Minimums.
-  EXPECT_EQ(0x00u, DecodeValidUint32(7, string("\x00", 1)));
+  EXPECT_EQ(0x00u, DecodeValidUint32(7, SpdyString("\x00", 1)));
   EXPECT_EQ(0x00u, DecodeValidUint32(7, "\x80"));
-  EXPECT_EQ(0x00u, DecodeValidUint32(6, string("\x00", 1)));
+  EXPECT_EQ(0x00u, DecodeValidUint32(6, SpdyString("\x00", 1)));
   EXPECT_EQ(0x00u, DecodeValidUint32(6, "\xc0"));
-  EXPECT_EQ(0x00u, DecodeValidUint32(5, string("\x00", 1)));
+  EXPECT_EQ(0x00u, DecodeValidUint32(5, SpdyString("\x00", 1)));
   EXPECT_EQ(0x00u, DecodeValidUint32(5, "\xe0"));
-  EXPECT_EQ(0x00u, DecodeValidUint32(4, string("\x00", 1)));
+  EXPECT_EQ(0x00u, DecodeValidUint32(4, SpdyString("\x00", 1)));
   EXPECT_EQ(0x00u, DecodeValidUint32(4, "\xf0"));
-  EXPECT_EQ(0x00u, DecodeValidUint32(3, string("\x00", 1)));
+  EXPECT_EQ(0x00u, DecodeValidUint32(3, SpdyString("\x00", 1)));
   EXPECT_EQ(0x00u, DecodeValidUint32(3, "\xf8"));
-  EXPECT_EQ(0x00u, DecodeValidUint32(2, string("\x00", 1)));
+  EXPECT_EQ(0x00u, DecodeValidUint32(2, SpdyString("\x00", 1)));
   EXPECT_EQ(0x00u, DecodeValidUint32(2, "\xfc"));
-  EXPECT_EQ(0x00u, DecodeValidUint32(1, string("\x00", 1)));
+  EXPECT_EQ(0x00u, DecodeValidUint32(1, SpdyString("\x00", 1)));
   EXPECT_EQ(0x00u, DecodeValidUint32(1, "\xfe"));
 
   // Maximums.
   EXPECT_EQ(0x7eu, DecodeValidUint32(7, "\x7e"));
   EXPECT_EQ(0x7eu, DecodeValidUint32(7, "\xfe"));
   EXPECT_EQ(0x3eu, DecodeValidUint32(6, "\x3e"));
   EXPECT_EQ(0x3eu, DecodeValidUint32(6, "\xfe"));
   EXPECT_EQ(0x1eu, DecodeValidUint32(5, "\x1e"));
   EXPECT_EQ(0x1eu, DecodeValidUint32(5, "\xfe"));
   EXPECT_EQ(0x0eu, DecodeValidUint32(4, "\x0e"));
   EXPECT_EQ(0x0eu, DecodeValidUint32(4, "\xfe"));
   EXPECT_EQ(0x06u, DecodeValidUint32(3, "\x06"));
   EXPECT_EQ(0x06u, DecodeValidUint32(3, "\xfe"));
   EXPECT_EQ(0x02u, DecodeValidUint32(2, "\x02"));
   EXPECT_EQ(0x02u, DecodeValidUint32(2, "\xfe"));
-  EXPECT_EQ(0x00u, DecodeValidUint32(1, string("\x00", 1)));
+  EXPECT_EQ(0x00u, DecodeValidUint32(1, SpdyString("\x00", 1)));
   EXPECT_EQ(0x00u, DecodeValidUint32(1, "\xfe"));
 
   // Invalid.
   ExpectDecodeUint32Invalid(7, "\x7f");
   ExpectDecodeUint32Invalid(7, "\xff");
   ExpectDecodeUint32Invalid(6, "\x3f");
   ExpectDecodeUint32Invalid(6, "\xff");
   ExpectDecodeUint32Invalid(5, "\x1f");
   ExpectDecodeUint32Invalid(5, "\xff");
   ExpectDecodeUint32Invalid(4, "\x0f");
   ExpectDecodeUint32Invalid(4, "\xff");
   ExpectDecodeUint32Invalid(3, "\x07");
   ExpectDecodeUint32Invalid(3, "\xff");
   ExpectDecodeUint32Invalid(2, "\x03");
   ExpectDecodeUint32Invalid(2, "\xff");
   ExpectDecodeUint32Invalid(1, "\x01");
   ExpectDecodeUint32Invalid(1, "\xff");
 }
 
 TEST(HpackInputStreamTest, TwoByteIntegersOneToSevenBitPrefixes) {
   // Minimums.
-  EXPECT_EQ(0x7fu, DecodeValidUint32(7, string("\x7f\x00", 2)));
-  EXPECT_EQ(0x7fu, DecodeValidUint32(7, string("\xff\x00", 2)));
-  EXPECT_EQ(0x3fu, DecodeValidUint32(6, string("\x3f\x00", 2)));
-  EXPECT_EQ(0x3fu, DecodeValidUint32(6, string("\xff\x00", 2)));
-  EXPECT_EQ(0x1fu, DecodeValidUint32(5, string("\x1f\x00", 2)));
-  EXPECT_EQ(0x1fu, DecodeValidUint32(5, string("\xff\x00", 2)));
-  EXPECT_EQ(0x0fu, DecodeValidUint32(4, string("\x0f\x00", 2)));
-  EXPECT_EQ(0x0fu, DecodeValidUint32(4, string("\xff\x00", 2)));
-  EXPECT_EQ(0x07u, DecodeValidUint32(3, string("\x07\x00", 2)));
-  EXPECT_EQ(0x07u, DecodeValidUint32(3, string("\xff\x00", 2)));
-  EXPECT_EQ(0x03u, DecodeValidUint32(2, string("\x03\x00", 2)));
-  EXPECT_EQ(0x03u, DecodeValidUint32(2, string("\xff\x00", 2)));
-  EXPECT_EQ(0x01u, DecodeValidUint32(1, string("\x01\x00", 2)));
-  EXPECT_EQ(0x01u, DecodeValidUint32(1, string("\xff\x00", 2)));
+  EXPECT_EQ(0x7fu, DecodeValidUint32(7, SpdyString("\x7f\x00", 2)));
+  EXPECT_EQ(0x7fu, DecodeValidUint32(7, SpdyString("\xff\x00", 2)));
+  EXPECT_EQ(0x3fu, DecodeValidUint32(6, SpdyString("\x3f\x00", 2)));
+  EXPECT_EQ(0x3fu, DecodeValidUint32(6, SpdyString("\xff\x00", 2)));
+  EXPECT_EQ(0x1fu, DecodeValidUint32(5, SpdyString("\x1f\x00", 2)));
+  EXPECT_EQ(0x1fu, DecodeValidUint32(5, SpdyString("\xff\x00", 2)));
+  EXPECT_EQ(0x0fu, DecodeValidUint32(4, SpdyString("\x0f\x00", 2)));
+  EXPECT_EQ(0x0fu, DecodeValidUint32(4, SpdyString("\xff\x00", 2)));
+  EXPECT_EQ(0x07u, DecodeValidUint32(3, SpdyString("\x07\x00", 2)));
+  EXPECT_EQ(0x07u, DecodeValidUint32(3, SpdyString("\xff\x00", 2)));
+  EXPECT_EQ(0x03u, DecodeValidUint32(2, SpdyString("\x03\x00", 2)));
+  EXPECT_EQ(0x03u, DecodeValidUint32(2, SpdyString("\xff\x00", 2)));
+  EXPECT_EQ(0x01u, DecodeValidUint32(1, SpdyString("\x01\x00", 2)));
+  EXPECT_EQ(0x01u, DecodeValidUint32(1, SpdyString("\xff\x00", 2)));
 
   // Maximums.
   EXPECT_EQ(0xfeu, DecodeValidUint32(7, "\x7f\x7f"));
   EXPECT_EQ(0xfeu, DecodeValidUint32(7, "\xff\x7f"));
   EXPECT_EQ(0xbeu, DecodeValidUint32(6, "\x3f\x7f"));
   EXPECT_EQ(0xbeu, DecodeValidUint32(6, "\xff\x7f"));
   EXPECT_EQ(0x9eu, DecodeValidUint32(5, "\x1f\x7f"));
   EXPECT_EQ(0x9eu, DecodeValidUint32(5, "\xff\x7f"));
   EXPECT_EQ(0x8eu, DecodeValidUint32(4, "\x0f\x7f"));
   EXPECT_EQ(0x8eu, DecodeValidUint32(4, "\xff\x7f"));
@@ skipping 267 matching lines @@
   // Set the length to be one more than it should be.
   HpackInputStream input_stream("\x0fstring literal");
 
   EXPECT_TRUE(input_stream.HasMoreData());
   SpdyStringPiece string_piece;
   EXPECT_FALSE(input_stream.DecodeNextIdentityString(&string_piece));
   EXPECT_TRUE(input_stream.NeedMoreData());
 }
 
 TEST(HpackInputStreamTest, DecodeNextHuffmanString) {
-  string output, input(a2b_hex(kEncodedHuffmanFixture));
+  SpdyString output, input(a2b_hex(kEncodedHuffmanFixture));
   HpackInputStream input_stream(input);
   HpackInputStreamPeer input_stream_peer(&input_stream);
 
   EXPECT_TRUE(input_stream.HasMoreData());
   EXPECT_TRUE(input_stream.DecodeNextHuffmanString(&output));
   EXPECT_EQ(kDecodedHuffmanFixture, output);
   EXPECT_FALSE(input_stream.HasMoreData());
   EXPECT_FALSE(input_stream.NeedMoreData());
   EXPECT_EQ(46u, input_stream_peer.ParsedBytesCurrent());
 }
 
 TEST(HpackInputStreamTest, DecodeNextHuffmanStringNotEnoughInput) {
-  string output, input(a2b_hex(kEncodedHuffmanFixture));
+  SpdyString output, input(a2b_hex(kEncodedHuffmanFixture));
   input[0]++;  // Input prefix is one byte larger than available input.
   HpackInputStream input_stream(input);
 
   // Not enough buffer for declared encoded length.
   EXPECT_TRUE(input_stream.HasMoreData());
   EXPECT_FALSE(input_stream.DecodeNextHuffmanString(&output));
   EXPECT_TRUE(input_stream.NeedMoreData());
 }
 
 TEST(HpackInputStreamTest, PeekBitsAndConsume) {
@@ skipping 210 matching lines @@
 
   HpackInputStream input_stream2("\x0e");
   HpackInputStreamPeer input_stream2_peer(&input_stream2);
   EXPECT_FALSE(input_stream2.DecodeNextIdentityString(&string_piece));
   // Only parsed first byte.
   EXPECT_EQ(1u, input_stream2_peer.ParsedBytesCurrent());
   EXPECT_TRUE(input_stream2.NeedMoreData());
 }
 
 TEST(HpackInputStreamTest, IncompleteHeaderDecodeNextHuffmanString) {
-  string output, input(a2b_hex(kEncodedHuffmanFixture));
+  SpdyString output, input(a2b_hex(kEncodedHuffmanFixture));
   input.resize(input.size() - 1);  // Remove last byte.
   HpackInputStream input_stream1(input);
   HpackInputStreamPeer input_stream1_peer(&input_stream1);
   EXPECT_FALSE(input_stream1.DecodeNextHuffmanString(&output));
   EXPECT_EQ(1u, input_stream1_peer.ParsedBytesCurrent());
   EXPECT_TRUE(input_stream1.NeedMoreData());
 
   input.erase(1, input.size());  // Remove all bytes except the first one.
   HpackInputStream input_stream2(input);
   HpackInputStreamPeer input_stream2_peer(&input_stream2);
   EXPECT_FALSE(input_stream2.DecodeNextHuffmanString(&output));
   EXPECT_EQ(1u, input_stream2_peer.ParsedBytesCurrent());
   EXPECT_TRUE(input_stream2.NeedMoreData());
 }
 
 }  // namespace test
 
 }  // namespace net