Make SpdyHeaderBlock non-copyable.

net/spdy/hpack/hpack_decoder_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_decoder.h"
 
 #include <map>
 #include <string>
 
 #include "base/logging.h"
@@ skipping 292 matching lines @@
   StringPiece string_piece;
   EXPECT_FALSE(decoder_peer_.DecodeNextName(&input_stream, &string_piece));
   EXPECT_FALSE(input_stream.NeedMoreData());
   input_stream.MarkCurrentPosition();
   EXPECT_EQ(1u, input_stream.ParsedBytes());
 }
 
 // Decoding indexed static table field should work.
 TEST_P(HpackDecoderTest, IndexedHeaderStatic) {
   // Reference static table entries #2 and #5.
-  SpdyHeaderBlock header_set1 = DecodeBlockExpectingSuccess("\x82\x85");
+  const SpdyHeaderBlock& header_set1 = DecodeBlockExpectingSuccess("\x82\x85");
   SpdyHeaderBlock expected_header_set1;
   expected_header_set1[":method"] = "GET";
   expected_header_set1[":path"] = "/index.html";
   EXPECT_EQ(expected_header_set1, header_set1);
 
   // Reference static table entry #2.
-  SpdyHeaderBlock header_set2 = DecodeBlockExpectingSuccess("\x82");
+  const SpdyHeaderBlock& header_set2 = DecodeBlockExpectingSuccess("\x82");
   SpdyHeaderBlock expected_header_set2;
   expected_header_set2[":method"] = "GET";
   EXPECT_EQ(expected_header_set2, header_set2);
 }
 
 TEST_P(HpackDecoderTest, IndexedHeaderDynamic) {
   // First header block: add an entry to header table.
-  SpdyHeaderBlock header_set1 = DecodeBlockExpectingSuccess(
+  const SpdyHeaderBlock& header_set1 = DecodeBlockExpectingSuccess(
       "\x40\x03"
       "foo"
       "\x03"
       "bar");
   SpdyHeaderBlock expected_header_set1;
   expected_header_set1["foo"] = "bar";
   EXPECT_EQ(expected_header_set1, header_set1);
 
   // Second header block: add another entry to header table.
-  SpdyHeaderBlock header_set2 = DecodeBlockExpectingSuccess(
+  const SpdyHeaderBlock& header_set2 = DecodeBlockExpectingSuccess(
       "\xbe\x40\x04"
       "spam"
       "\x04"
       "eggs");
   SpdyHeaderBlock expected_header_set2;
   expected_header_set2["foo"] = "bar";
   expected_header_set2["spam"] = "eggs";
   EXPECT_EQ(expected_header_set2, header_set2);
 
   // Third header block: refer to most recently added entry.
-  SpdyHeaderBlock header_set3 = DecodeBlockExpectingSuccess("\xbe");
+  const SpdyHeaderBlock& header_set3 = DecodeBlockExpectingSuccess("\xbe");
   SpdyHeaderBlock expected_header_set3;
   expected_header_set3["spam"] = "eggs";
   EXPECT_EQ(expected_header_set3, header_set3);
 }
 
 // Test a too-large indexed header.
 TEST_P(HpackDecoderTest, InvalidIndexedHeader) {
   // High-bit set, and a prefix of one more than the number of static entries.
   EXPECT_FALSE(DecodeHeaderBlock(StringPiece("\xbe", 1)));
 }
@@ skipping 117 matching lines @@
     EXPECT_EQ(60u, decoder_peer_.header_table()->max_size());
   }
 }
 
 // Decoding two valid encoded literal headers with no indexing should
 // work.
 TEST_P(HpackDecoderTest, LiteralHeaderNoIndexing) {
   // First header with indexed name, second header with string literal
   // name.
   const char input[] = "\x04\x0c/sample/path\x00\x06:path2\x0e/sample/path/2";
-  SpdyHeaderBlock header_set =
+  const SpdyHeaderBlock& header_set =
       DecodeBlockExpectingSuccess(StringPiece(input, arraysize(input) - 1));
 
   SpdyHeaderBlock expected_header_set;
   expected_header_set[":path"] = "/sample/path";
   expected_header_set[":path2"] = "/sample/path/2";
   EXPECT_EQ(expected_header_set, header_set);
 }
 
 // Decoding two valid encoded literal headers with incremental
 // indexing and string literal names should work.
 TEST_P(HpackDecoderTest, LiteralHeaderIncrementalIndexing) {
   const char input[] = "\x44\x0c/sample/path\x40\x06:path2\x0e/sample/path/2";
-  SpdyHeaderBlock header_set =
+  const SpdyHeaderBlock& header_set =
       DecodeBlockExpectingSuccess(StringPiece(input, arraysize(input) - 1));
 
   SpdyHeaderBlock expected_header_set;
   expected_header_set[":path"] = "/sample/path";
   expected_header_set[":path2"] = "/sample/path/2";
   EXPECT_EQ(expected_header_set, header_set);
 }
 
 TEST_P(HpackDecoderTest, LiteralHeaderWithIndexingInvalidNameIndex) {
   decoder_.ApplyHeaderTableSizeSetting(0);
@@ skipping 54 matching lines @@
 
   string 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());
 }
 
 TEST_P(HpackDecoderTest, SectionD4RequestHuffmanExamples) {
-  SpdyHeaderBlock header_set;
-
   // 82                                      | == Indexed - Add ==
   //                                         |   idx = 2
   //                                         | -> :method: GET
   // 86                                      | == Indexed - Add ==
   //                                         |   idx = 6
   //                                         | -> :scheme: http
   // 84                                      | == Indexed - Add ==
   //                                         |   idx = 4
   //                                         | -> :path: /
   // 41                                      | == Literal indexed ==
   //                                         |   Indexed name (idx = 1)
   //                                         |     :authority
   // 8c                                      |   Literal value (len = 15)
   //                                         |     Huffman encoded:
   // f1e3 c2e5 f23a 6ba0 ab90 f4ff           | .....:k.....
   //                                         |     Decoded:
   //                                         | www.example.com
   //                                         | -> :authority: www.example.com
-  string first = a2b_hex(
-      "828684418cf1e3c2e5f23a6ba0ab90f4"
-      "ff");
-  header_set = DecodeBlockExpectingSuccess(first);
+  string first = a2b_hex("828684418cf1e3c2e5f23a6ba0ab90f4ff");
+  const SpdyHeaderBlock& first_header_set = DecodeBlockExpectingSuccess(first);
 
   EXPECT_THAT(
-      header_set,
+      first_header_set,
       ElementsAre(Pair(":method", "GET"), Pair(":scheme", "http"),
                   Pair(":path", "/"), Pair(":authority", "www.example.com")));
 
   expectEntry(62, 57, ":authority", "www.example.com");
   EXPECT_EQ(57u, decoder_peer_.header_table()->size());
 
   // 82                                      | == Indexed - Add ==
   //                                         |   idx = 2
   //                                         | -> :method: GET
   // 86                                      | == Indexed - Add ==
   //                                         |   idx = 6
   //                                         | -> :scheme: http
   // 84                                      | == Indexed - Add ==
   //                                         |   idx = 4
   //                                         | -> :path: /
   // be                                      | == Indexed - Add ==
   //                                         |   idx = 62
   //                                         | -> :authority: www.example.com
   // 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");
-  header_set = DecodeBlockExpectingSuccess(second);
+  const SpdyHeaderBlock& second_header_set =
+      DecodeBlockExpectingSuccess(second);
 
   EXPECT_THAT(
-      header_set,
+      second_header_set,
       ElementsAre(Pair(":method", "GET"), Pair(":scheme", "http"),
                   Pair(":path", "/"), Pair(":authority", "www.example.com"),
                   Pair("cache-control", "no-cache")));
 
   expectEntry(62, 53, "cache-control", "no-cache");
   expectEntry(63, 57, ":authority", "www.example.com");
   EXPECT_EQ(110u, decoder_peer_.header_table()->size());
 
   // 82                                      | == Indexed - Add ==
   //                                         |   idx = 2
@@ skipping 15 matching lines @@
   //                                         | 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(
       "828785bf408825a849e95ba97d7f89"
       "25a849e95bb8e8b4bf");
-  header_set = DecodeBlockExpectingSuccess(third);
+  const SpdyHeaderBlock& third_header_set = DecodeBlockExpectingSuccess(third);
 
-  EXPECT_THAT(header_set,
+  EXPECT_THAT(third_header_set,
               ElementsAre(Pair(":method", "GET"), Pair(":scheme", "https"),
                           Pair(":path", "/index.html"),
                           Pair(":authority", "www.example.com"),
                           Pair("custom-key", "custom-value")));
 
   expectEntry(62, 54, "custom-key", "custom-value");
   expectEntry(63, 53, "cache-control", "no-cache");
   expectEntry(64, 57, ":authority", "www.example.com");
   EXPECT_EQ(164u, decoder_peer_.header_table()->size());
 }
 
 TEST_P(HpackDecoderTest, SectionD6ResponseHuffmanExamples) {
-  SpdyHeaderBlock header_set;
   decoder_.ApplyHeaderTableSizeSetting(256);
 
   // 48                                      | == Literal indexed ==
   //                                         |   Indexed name (idx = 8)
   //                                         |     :status
   // 82                                      |   Literal value (len = 3)
   //                                         |     Huffman encoded:
   // 6402                                    | d.
   //                                         |     Decoded:
   //                                         | 302
@@ skipping 29 matching lines @@
   //                                         |     Decoded:
   //                                         | https://www.example.com
   //                                         | -> location: https://www.e
   //                                         |    xample.com
 
   string first = a2b_hex(
       "488264025885aec3771a4b6196d07abe"
       "941054d444a8200595040b8166e082a6"
       "2d1bff6e919d29ad171863c78f0b97c8"
       "e9ae82ae43d3");
-  header_set = DecodeBlockExpectingSuccess(first);
+  const SpdyHeaderBlock& first_header_set = DecodeBlockExpectingSuccess(first);
 
   EXPECT_THAT(
-      header_set,
+      first_header_set,
       ElementsAre(Pair(":status", "302"), Pair("cache-control", "private"),
                   Pair("date", "Mon, 21 Oct 2013 20:13:21 GMT"),
                   Pair("location", "https://www.example.com")));
 
   expectEntry(62, 63, "location", "https://www.example.com");
   expectEntry(63, 65, "date", "Mon, 21 Oct 2013 20:13:21 GMT");
   expectEntry(64, 52, "cache-control", "private");
   expectEntry(65, 42, ":status", "302");
   EXPECT_EQ(222u, decoder_peer_.header_table()->size());
 
@@ skipping 12 matching lines @@
   //                                         | -> 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");
-  header_set = DecodeBlockExpectingSuccess(second);
+  const SpdyHeaderBlock& second_header_set =
+      DecodeBlockExpectingSuccess(second);
 
   EXPECT_THAT(
-      header_set,
+      second_header_set,
       ElementsAre(Pair(":status", "307"), Pair("cache-control", "private"),
                   Pair("date", "Mon, 21 Oct 2013 20:13:21 GMT"),
                   Pair("location", "https://www.example.com")));
 
   expectEntry(62, 42, ":status", "307");
   expectEntry(63, 63, "location", "https://www.example.com");
   expectEntry(64, 65, "date", "Mon, 21 Oct 2013 20:13:21 GMT");
   expectEntry(65, 52, "cache-control", "private");
   EXPECT_EQ(222u, decoder_peer_.header_table()->size());
 
@@ skipping 49 matching lines @@
   //                                         | - evict: :status: 307
   //                                         | -> set-cookie: foo=ASDJKHQ
   //                                         |   KBZXOQWEOPIUAXQWEOIU;
   //                                         |   max-age=3600; version=1
   string third = a2b_hex(
       "88c16196d07abe941054d444a8200595"
       "040b8166e084a62d1bffc05a839bd9ab"
       "77ad94e7821dd7f2e6c7b335dfdfcd5b"
       "3960d5af27087f3672c1ab270fb5291f"
       "9587316065c003ed4ee5b1063d5007");
-  header_set = DecodeBlockExpectingSuccess(third);
+  const SpdyHeaderBlock& third_header_set = DecodeBlockExpectingSuccess(third);
 
   EXPECT_THAT(
-      header_set,
+      third_header_set,
       ElementsAre(Pair(":status", "200"), Pair("cache-control", "private"),
                   Pair("date", "Mon, 21 Oct 2013 20:13:22 GMT"),
                   Pair("location", "https://www.example.com"),
                   Pair("content-encoding", "gzip"),
                   Pair("set-cookie",
                        "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU;"
                        " max-age=3600; version=1")));
 
   expectEntry(62, 98, "set-cookie",
               "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU;"
               " max-age=3600; version=1");
   expectEntry(63, 52, "content-encoding", "gzip");
   expectEntry(64, 65, "date", "Mon, 21 Oct 2013 20:13:22 GMT");
   EXPECT_EQ(215u, decoder_peer_.header_table()->size());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net