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

net/spdy/hpack/hpack_decoder3_test.cc

 // Copyright 2017 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_decoder3.h"
 
 // Tests of HpackDecoder3.
 
 #include <stdint.h>
 
-#include <string>
 #include <tuple>
 #include <utility>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "net/http2/hpack/decoder/hpack_decoder_state.h"
 #include "net/http2/hpack/decoder/hpack_decoder_tables.h"
 #include "net/http2/hpack/tools/hpack_block_builder.h"
 #include "net/http2/tools/http2_random.h"
 #include "net/spdy/hpack/hpack_constants.h"
 #include "net/spdy/hpack/hpack_encoder.h"
 #include "net/spdy/hpack/hpack_huffman_table.h"
 #include "net/spdy/hpack/hpack_output_stream.h"
+#include "net/spdy/platform/api/spdy_string.h"
 #include "net/spdy/spdy_test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using std::string;
 using ::testing::ElementsAre;
 using ::testing::Pair;
 
 namespace net {
 namespace test {
 
 class HpackDecoderStatePeer {
  public:
   static HpackDecoderTables* GetDecoderTables(HpackDecoderState* state) {
     return &state->decoder_tables_;
@@ skipping 126 matching lines @@
     }
   }
 
   const SpdyHeaderBlock& DecodeBlockExpectingSuccess(SpdyStringPiece str) {
     EXPECT_TRUE(DecodeHeaderBlock(str));
     return decoded_block();
   }
 
   void expectEntry(size_t index,
                    size_t size,
-                   const string& name,
-                   const string& value) {
+                   const SpdyString& name,
+                   const SpdyString& value) {
     const HpackStringPair* entry = decoder_peer_.GetTableEntry(index);
     EXPECT_EQ(name, entry->name) << "index " << index;
     EXPECT_EQ(value, entry->value);
     EXPECT_EQ(size, entry->size());
   }
 
   SpdyHeaderBlock MakeHeaderBlock(
-      const std::vector<std::pair<string, string>>& headers) {
+      const std::vector<std::pair<SpdyString, SpdyString>>& headers) {
     SpdyHeaderBlock result;
     for (const auto& kv : headers) {
       result.AppendValueOrAddHeader(kv.first, kv.second);
     }
     return result;
   }
 
   Http2Random random_;
   HpackHuffmanTable huffman_table_;
   HpackDecoder3 decoder_;
@@ skipping 10 matching lines @@
     ::testing::Combine(
         ::testing::Values(START_WITH_HANDLER, START_WITHOUT_HANDLER, NO_START),
         ::testing::Bool()));
 
 TEST_P(HpackDecoder3Test, AddHeaderDataWithHandleControlFrameHeadersData) {
   // The hpack decode buffer size is limited in size. This test verifies that
   // adding encoded data under that limit is accepted, and data that exceeds the
   // limit is rejected.
   HandleControlFrameHeadersStart();
   const size_t kMaxBufferSizeBytes = 50;
-  const string a_value = string(49, 'x');
+  const SpdyString a_value = SpdyString(49, 'x');
   decoder_.set_max_decode_buffer_size_bytes(kMaxBufferSizeBytes);
   HpackBlockBuilder hbb;
   hbb.AppendLiteralNameAndValue(HpackEntryType::kNeverIndexedLiteralHeader,
                                 false, "a", false, a_value);
-  const string& s = hbb.buffer();
+  const SpdyString& s = hbb.buffer();
   EXPECT_GT(s.size(), kMaxBufferSizeBytes);
 
   // Any one in input buffer must not exceed kMaxBufferSizeBytes.
   EXPECT_TRUE(HandleControlFrameHeadersData(s.substr(0, s.size() / 2)));
   EXPECT_TRUE(HandleControlFrameHeadersData(s.substr(s.size() / 2)));
 
   EXPECT_FALSE(HandleControlFrameHeadersData(s));
   SpdyHeaderBlock expected_block = MakeHeaderBlock({{"a", a_value}});
   EXPECT_EQ(expected_block, decoded_block());
 }
 
 TEST_P(HpackDecoder3Test, NameTooLong) {
   // Verify that a name longer than the allowed size generates an error.
   const size_t kMaxBufferSizeBytes = 50;
-  const string name = string(2 * kMaxBufferSizeBytes, 'x');
-  const string value = "abc";
+  const SpdyString name = SpdyString(2 * kMaxBufferSizeBytes, 'x');
+  const SpdyString value = "abc";
 
   decoder_.set_max_decode_buffer_size_bytes(kMaxBufferSizeBytes);
 
   HpackBlockBuilder hbb;
   hbb.AppendLiteralNameAndValue(HpackEntryType::kNeverIndexedLiteralHeader,
                                 false, name, false, value);
 
   const size_t fragment_size = (3 * kMaxBufferSizeBytes) / 2;
-  const string fragment = hbb.buffer().substr(0, fragment_size);
+  const SpdyString fragment = hbb.buffer().substr(0, fragment_size);
 
   HandleControlFrameHeadersStart();
   EXPECT_FALSE(HandleControlFrameHeadersData(fragment));
 }
 
 TEST_P(HpackDecoder3Test, HeaderTooLongToBuffer) {
   // Verify that a header longer than the allowed size generates an error if
   // it isn't all in one input buffer.
-  const string name = "some-key";
-  const string value = "some-value";
+  const SpdyString name = "some-key";
+  const SpdyString value = "some-value";
   const size_t kMaxBufferSizeBytes = name.size() + value.size() - 2;
   decoder_.set_max_decode_buffer_size_bytes(kMaxBufferSizeBytes);
 
   HpackBlockBuilder hbb;
   hbb.AppendLiteralNameAndValue(HpackEntryType::kNeverIndexedLiteralHeader,
                                 false, name, false, value);
   const size_t fragment_size = hbb.size() - 1;
-  const string fragment = hbb.buffer().substr(0, fragment_size);
+  const SpdyString fragment = hbb.buffer().substr(0, fragment_size);
 
   HandleControlFrameHeadersStart();
   EXPECT_FALSE(HandleControlFrameHeadersData(fragment));
 }
 
 // Decode with incomplete data in buffer.
 TEST_P(HpackDecoder3Test, DecodeWithIncompleteData) {
   HandleControlFrameHeadersStart();
 
   // No need to wait for more data.
   EXPECT_TRUE(HandleControlFrameHeadersData("\x82\x85\x82"));
-  std::vector<std::pair<string, string>> expected_headers = {
+  std::vector<std::pair<SpdyString, SpdyString>> expected_headers = {
       {":method", "GET"}, {":path", "/index.html"}, {":method", "GET"}};
 
   SpdyHeaderBlock expected_block1 = MakeHeaderBlock(expected_headers);
   EXPECT_EQ(expected_block1, decoded_block());
 
   // Full and partial headers, won't add partial to the headers.
   EXPECT_TRUE(
       HandleControlFrameHeadersData("\x40\x03goo"
                                     "\x03gar\xbe\x40\x04spam"));
   expected_headers.push_back({"goo", "gar"});
@@ skipping 20 matching lines @@
   HandleControlFrameHeadersStart();
   HandleControlFrameHeadersData("");
 
   // All cookie crumbs are joined.
   decoder_peer_.HandleHeaderRepresentation("cookie", " part 1");
   decoder_peer_.HandleHeaderRepresentation("cookie", "part 2 ");
   decoder_peer_.HandleHeaderRepresentation("cookie", "part3");
 
   // Already-delimited headers are passed through.
   decoder_peer_.HandleHeaderRepresentation("passed-through",
-                                           string("foo\0baz", 7));
+                                           SpdyString("foo\0baz", 7));
 
   // Other headers are joined on \0. Case matters.
   decoder_peer_.HandleHeaderRepresentation("joined", "not joined");
   decoder_peer_.HandleHeaderRepresentation("joineD", "value 1");
   decoder_peer_.HandleHeaderRepresentation("joineD", "value 2");
 
   // Empty headers remain empty.
   decoder_peer_.HandleHeaderRepresentation("empty", "");
 
   // Joined empty headers work as expected.
@@ skipping 66 matching lines @@
 
 // Test a too-large indexed header.
 TEST_P(HpackDecoder3Test, InvalidIndexedHeader) {
   // High-bit set, and a prefix of one more than the number of static entries.
   EXPECT_FALSE(DecodeHeaderBlock("\xbe"));
 }
 
 TEST_P(HpackDecoder3Test, ContextUpdateMaximumSize) {
   EXPECT_EQ(kDefaultHeaderTableSizeSetting,
             decoder_peer_.header_table_size_limit());
-  string input;
+  SpdyString input;
   {
     // Maximum-size update with size 126. Succeeds.
     HpackOutputStream output_stream;
     output_stream.AppendPrefix(kHeaderTableSizeUpdateOpcode);
     output_stream.AppendUint32(126);
 
     output_stream.TakeString(&input);
     EXPECT_TRUE(DecodeHeaderBlock(SpdyStringPiece(input)));
     EXPECT_EQ(126u, decoder_peer_.header_table_size_limit());
   }
@@ skipping 16 matching lines @@
 
     output_stream.TakeString(&input);
     EXPECT_FALSE(DecodeHeaderBlock(SpdyStringPiece(input)));
     EXPECT_EQ(kDefaultHeaderTableSizeSetting,
               decoder_peer_.header_table_size_limit());
   }
 }
 
 // Two HeaderTableSizeUpdates may appear at the beginning of the block
 TEST_P(HpackDecoder3Test, TwoTableSizeUpdates) {
-  string input;
+  SpdyString input;
   {
     // Should accept two table size updates, update to second one
     HpackOutputStream output_stream;
     output_stream.AppendPrefix(kHeaderTableSizeUpdateOpcode);
     output_stream.AppendUint32(0);
     output_stream.AppendPrefix(kHeaderTableSizeUpdateOpcode);
     output_stream.AppendUint32(122);
 
     output_stream.TakeString(&input);
     EXPECT_TRUE(DecodeHeaderBlock(SpdyStringPiece(input)));
     EXPECT_EQ(122u, decoder_peer_.header_table_size_limit());
   }
 }
 
 // Three HeaderTableSizeUpdates should result in an error
 TEST_P(HpackDecoder3Test, ThreeTableSizeUpdatesError) {
-  string input;
+  SpdyString input;
   {
     // Should reject three table size updates, update to second one
     HpackOutputStream output_stream;
     output_stream.AppendPrefix(kHeaderTableSizeUpdateOpcode);
     output_stream.AppendUint32(5);
     output_stream.AppendPrefix(kHeaderTableSizeUpdateOpcode);
     output_stream.AppendUint32(10);
     output_stream.AppendPrefix(kHeaderTableSizeUpdateOpcode);
     output_stream.AppendUint32(15);
 
     output_stream.TakeString(&input);
 
     EXPECT_FALSE(DecodeHeaderBlock(SpdyStringPiece(input)));
     EXPECT_EQ(10u, decoder_peer_.header_table_size_limit());
   }
 }
 
 // HeaderTableSizeUpdates may only appear at the beginning of the block
 // Any other updates should result in an error
 TEST_P(HpackDecoder3Test, TableSizeUpdateSecondError) {
-  string input;
+  SpdyString input;
   {
     // Should reject a table size update appearing after a different entry
     // The table size should remain as the default
     HpackOutputStream output_stream;
     output_stream.AppendBytes("\x82\x85");
     output_stream.AppendPrefix(kHeaderTableSizeUpdateOpcode);
     output_stream.AppendUint32(123);
 
     output_stream.TakeString(&input);
 
     EXPECT_FALSE(DecodeHeaderBlock(SpdyStringPiece(input)));
     EXPECT_EQ(kDefaultHeaderTableSizeSetting,
               decoder_peer_.header_table_size_limit());
   }
 }
 
 // HeaderTableSizeUpdates may only appear at the beginning of the block
 // Any other updates should result in an error
 TEST_P(HpackDecoder3Test, TableSizeUpdateFirstThirdError) {
-  string input;
+  SpdyString input;
   {
     // Should reject the second table size update
     // if a different entry appears after the first update
     // The table size should update to the first but not the second
     HpackOutputStream output_stream;
     output_stream.AppendPrefix(kHeaderTableSizeUpdateOpcode);
     output_stream.AppendUint32(60);
     output_stream.AppendBytes("\x82\x85");
     output_stream.AppendPrefix(kHeaderTableSizeUpdateOpcode);
     output_stream.AppendUint32(125);
@@ skipping 70 matching lines @@
   // 41                                      | == Literal indexed ==
   //                                         |   Indexed name (idx = 1)
   //                                         |     :authority
   // 8c                                      |   Literal value (len = 12)
   //                                         |     Huffman encoded:
   // f1e3 c2e5 f23a 6ba0 ab90 f4ff           | .....:k.....
   //                                         |     Decoded:
   //                                         | www.example.com
   //                                         | -> :authority: www.example.com
 
-  string first = a2b_hex("418cf1e3c2e5f23a6ba0ab90f4ff");
+  SpdyString first = a2b_hex("418cf1e3c2e5f23a6ba0ab90f4ff");
   EXPECT_TRUE(DecodeHeaderBlock(first));
   first = a2b_hex("418cf1e3c2e5f23a6ba0ab90f4");
   EXPECT_FALSE(DecodeHeaderBlock(first));
 }
 
 TEST_P(HpackDecoder3Test, HuffmanEOSError) {
   // Literal value, Huffman encoded, but with an additional ff byte at the end
   // of the string, i.e. an EOS that is longer than permitted.
   //
   // 41                                      | == Literal indexed ==
   //                                         |   Indexed name (idx = 1)
   //                                         |     :authority
   // 8d                                      |   Literal value (len = 13)
   //                                         |     Huffman encoded:
   // f1e3 c2e5 f23a 6ba0 ab90 f4ff           | .....:k.....
   //                                         |     Decoded:
   //                                         | www.example.com
   //                                         | -> :authority: www.example.com
 
-  string first = a2b_hex("418cf1e3c2e5f23a6ba0ab90f4ff");
+  SpdyString first = a2b_hex("418cf1e3c2e5f23a6ba0ab90f4ff");
   EXPECT_TRUE(DecodeHeaderBlock(first));
   first = a2b_hex("418df1e3c2e5f23a6ba0ab90f4ffff");
   EXPECT_FALSE(DecodeHeaderBlock(first));
 }
 
 // Round-tripping the header set from RFC 7541 C.3.1 should work.
 // http://httpwg.org/specs/rfc7541.html#rfc.section.C.3.1
 TEST_P(HpackDecoder3Test, BasicC31) {
   HpackEncoder encoder(ObtainHpackHuffmanTable());
 
   SpdyHeaderBlock expected_header_set;
   expected_header_set[":method"] = "GET";
   expected_header_set[":scheme"] = "http";
   expected_header_set[":path"] = "/";
   expected_header_set[":authority"] = "www.example.com";
 
-  string encoded_header_set;
+  SpdyString encoded_header_set;
   EXPECT_TRUE(
       encoder.EncodeHeaderSet(expected_header_set, &encoded_header_set));
 
   EXPECT_TRUE(DecodeHeaderBlock(encoded_header_set));
   EXPECT_EQ(expected_header_set, decoded_block());
 }
 
 // RFC 7541, Section C.4: Request Examples with Huffman Coding
 // http://httpwg.org/specs/rfc7541.html#rfc.section.C.4
 TEST_P(HpackDecoder3Test, SectionC4RequestHuffmanExamples) {
@@ skipping 10 matching lines @@
   //                                         | -> :path: /
   // 41                                      | == Literal indexed ==
   //                                         |   Indexed name (idx = 1)
   //                                         |     :authority
   // 8c                                      |   Literal value (len = 12)
   //                                         |     Huffman encoded:
   // f1e3 c2e5 f23a 6ba0 ab90 f4ff           | .....:k.....
   //                                         |     Decoded:
   //                                         | www.example.com
   //                                         | -> :authority: www.example.com
-  string first = a2b_hex("828684418cf1e3c2e5f23a6ba0ab90f4ff");
+  SpdyString first = a2b_hex("828684418cf1e3c2e5f23a6ba0ab90f4ff");
   const SpdyHeaderBlock& first_header_set = DecodeBlockExpectingSuccess(first);
 
   EXPECT_THAT(first_header_set,
               ElementsAre(
                   // clang-format off
       Pair(":method", "GET"),
       Pair(":scheme", "http"),
       Pair(":path", "/"),
       Pair(":authority", "www.example.com")));
   // clang-format on
@@ skipping 16 matching lines @@
   // 58                                      | == Literal indexed ==
   //                                         |   Indexed name (idx = 24)
   //                                         |     cache-control
   // 86                                      |   Literal value (len = 8)
   //                                         |     Huffman encoded:
   // a8eb 1064 9cbf                          | ...d..
   //                                         |     Decoded:
   //                                         | no-cache
   //                                         | -> cache-control: no-cache
 
-  string second = a2b_hex("828684be5886a8eb10649cbf");
+  SpdyString second = a2b_hex("828684be5886a8eb10649cbf");
   const SpdyHeaderBlock& second_header_set =
       DecodeBlockExpectingSuccess(second);
 
   EXPECT_THAT(second_header_set,
               ElementsAre(
                   // clang-format off
       Pair(":method", "GET"),
       Pair(":scheme", "http"),
       Pair(":path", "/"),
       Pair(":authority", "www.example.com"),
@@ skipping 21 matching lines @@
   //                                         |     Huffman encoded:
   // 25a8 49e9 5ba9 7d7f                     | %.I.[.}.
   //                                         |     Decoded:
   //                                         | custom-key
   // 89                                      |   Literal value (len = 12)
   //                                         |     Huffman encoded:
   // 25a8 49e9 5bb8 e8b4 bf                  | %.I.[....
   //                                         |     Decoded:
   //                                         | custom-value
   //                                         | -> custom-key: custom-value
-  string third = a2b_hex("828785bf408825a849e95ba97d7f8925a849e95bb8e8b4bf");
+  SpdyString third =
+      a2b_hex("828785bf408825a849e95ba97d7f8925a849e95bb8e8b4bf");
   const SpdyHeaderBlock& third_header_set = DecodeBlockExpectingSuccess(third);
 
   EXPECT_THAT(
       third_header_set,
       ElementsAre(
           // clang-format off
       Pair(":method", "GET"),
       Pair(":scheme", "https"),
       Pair(":path", "/index.html"),
       Pair(":authority", "www.example.com"),
@@ skipping 48 matching lines @@
   //                                         |     location
   // 91                                      |   Literal value (len = 23)
   //                                         |     Huffman encoded:
   // 9d29 ad17 1863 c78f 0b97 c8e9 ae82 ae43 | .)...c.........C
   // d3                                      | .
   //                                         |     Decoded:
   //                                         | https://www.example.com
   //                                         | -> location: https://www.e
   //                                         |    xample.com
 
-  string first = a2b_hex(
+  SpdyString first = a2b_hex(
       "488264025885aec3771a4b6196d07abe"
       "941054d444a8200595040b8166e082a6"
       "2d1bff6e919d29ad171863c78f0b97c8"
       "e9ae82ae43d3");
   const SpdyHeaderBlock& first_header_set = DecodeBlockExpectingSuccess(first);
 
   EXPECT_THAT(first_header_set,
               ElementsAre(
                   // clang-format off
       Pair(":status", "302"),
@@ skipping 22 matching lines @@
   //                                         |   idx = 65
   //                                         | -> cache-control: private
   // c0                                      | == Indexed - Add ==
   //                                         |   idx = 64
   //                                         | -> date: Mon, 21 Oct 2013
   //                                         |   20:13:21 GMT
   // bf                                      | == Indexed - Add ==
   //                                         |   idx = 63
   //                                         | -> location:
   //                                         |   https://www.example.com
-  string second = a2b_hex("4883640effc1c0bf");
+  SpdyString second = a2b_hex("4883640effc1c0bf");
   const SpdyHeaderBlock& second_header_set =
       DecodeBlockExpectingSuccess(second);
 
   EXPECT_THAT(second_header_set,
               ElementsAre(
                   // clang-format off
       Pair(":status", "307"),
       Pair("cache-control", "private"),
       Pair("date", "Mon, 21 Oct 2013 20:13:21 GMT"),
       Pair("location", "https://www.example.com")));
@@ skipping 51 matching lines @@
   //                                         |     Decoded:
   //                                         | foo=ASDJKHQKBZXOQWEOPIUAXQ
   //                                         | WEOIU; max-age=3600; versi
   //                                         | on=1
   //                                         | - evict: location:
   //                                         |   https://www.example.com
   //                                         | - evict: :status: 307
   //                                         | -> set-cookie: foo=ASDJKHQ
   //                                         |   KBZXOQWEOPIUAXQWEOIU;
   //                                         |   max-age=3600; version=1
-  string third = a2b_hex(
+  SpdyString third = a2b_hex(
       "88c16196d07abe941054d444a8200595"
       "040b8166e084a62d1bffc05a839bd9ab"
       "77ad94e7821dd7f2e6c7b335dfdfcd5b"
       "3960d5af27087f3672c1ab270fb5291f"
       "9587316065c003ed4ee5b1063d5007");
   const SpdyHeaderBlock& third_header_set = DecodeBlockExpectingSuccess(third);
 
   EXPECT_THAT(third_header_set,
               ElementsAre(
                   // clang-format off
@@ skipping 60 matching lines @@
   SpdyHeaderBlock expected_header_set;
   expected_header_set.AppendValueOrAddHeader(name, value1);
   expected_header_set.AppendValueOrAddHeader(name, value1);
   expected_header_set.AppendValueOrAddHeader(name, value2);
   expected_header_set.AppendValueOrAddHeader(name, value2);
   expected_header_set.AppendValueOrAddHeader(name, value3);
   expected_header_set.AppendValueOrAddHeader(name, value3);
 
   // SpdyHeaderBlock stores these 6 strings as '\0' separated values.
   // Make sure that is what happened.
-  string joined_values = expected_header_set[name].as_string();
+  SpdyString joined_values = expected_header_set[name].as_string();
   EXPECT_EQ(joined_values.size(),
             2 * value1.size() + 2 * value2.size() + 2 * value3.size() + 5);
 
   EXPECT_EQ(expected_header_set, decoded_block());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net