Replace SpdyNameValueBlock typedef with SpdyHeaderBlock.

Replace SpdyNameValueBlock typedef with SpdyHeaderBlock. Use SpdyHeaderBlock typedef more widely. No behavior change intended.

This CL is preparation for replacing SpdyHeaderBlock with an ordered datatype. Using the typedef in every place that currently explicitly uses map<string,string> will make this easier.

Other cleanup: replacing NameValueBlock with HeaderBlock, as in every case this is being used to store headers.

This CL lands server change 98865397 by rjshade.

BUG=443287

Review URL: https://codereview.chromium.org/1263803002

Cr-Commit-Position: refs/heads/master@{#341101}

20 files changed, 181 insertions, 208 deletions

diff --git a/net/spdy/buffered_spdy_framer.cc b/net/spdy/buffered_spdy_framer.cc
index 0bbbfdc..239e49f 100644
--- a/net/spdy/buffered_spdy_framer.cc
+++ b/net/spdy/buffered_spdy_framer.cc
@@ -299,7 +299,7 @@ SpdyFrame* BufferedSpdyFramer::CreateSynStream(
   syn_stream.set_fin((flags & CONTROL_FLAG_FIN) != 0);
   syn_stream.set_unidirectional((flags & CONTROL_FLAG_UNIDIRECTIONAL) != 0);
   // TODO(hkhalil): Avoid copy here.
-  syn_stream.set_name_value_block(*headers);
+  syn_stream.set_header_block(*headers);
   return spdy_framer_.SerializeSynStream(syn_stream);
 }
 
@@ -312,7 +312,7 @@ SpdyFrame* BufferedSpdyFramer::CreateSynReply(
   SpdySynReplyIR syn_reply(stream_id);
   syn_reply.set_fin(flags & CONTROL_FLAG_FIN);
   // TODO(hkhalil): Avoid copy here.
-  syn_reply.set_name_value_block(*headers);
+  syn_reply.set_header_block(*headers);
   return spdy_framer_.SerializeSynReply(syn_reply);
 }
 
@@ -372,7 +372,7 @@ SpdyFrame* BufferedSpdyFramer::CreateHeaders(
     headers_ir.set_has_priority(true);
     headers_ir.set_priority(priority);
   }
-  headers_ir.set_name_value_block(*headers);
+  headers_ir.set_header_block(*headers);
   return spdy_framer_.SerializeHeaders(headers_ir);
 }
 
@@ -402,7 +402,7 @@ SpdyFrame* BufferedSpdyFramer::CreatePushPromise(
     SpdyStreamId promised_stream_id,
     const SpdyHeaderBlock* headers) {
   SpdyPushPromiseIR push_promise_ir(stream_id, promised_stream_id);
-  push_promise_ir.set_name_value_block(*headers);
+  push_promise_ir.set_header_block(*headers);
   return spdy_framer_.SerializePushPromise(push_promise_ir);
 }
 
diff --git a/net/spdy/fuzzing/hpack_example_generator.cc b/net/spdy/fuzzing/hpack_example_generator.cc
index 8c0824a..aeebcf2 100644
--- a/net/spdy/fuzzing/hpack_example_generator.cc
+++ b/net/spdy/fuzzing/hpack_example_generator.cc
@@ -10,6 +10,7 @@
 #include "net/spdy/fuzzing/hpack_fuzz_util.h"
 #include "net/spdy/hpack_constants.h"
 #include "net/spdy/hpack_encoder.h"
+#include "net/spdy/spdy_protocol.h"
 
 namespace {
 
@@ -58,7 +59,7 @@ int main(int argc, char** argv) {
   net::HpackEncoder encoder(net::ObtainHpackHuffmanTable());
 
   for (int i = 0; i != example_count; ++i) {
-    map<string, string> headers =
+    net::SpdyHeaderBlock headers =
         HpackFuzzUtil::NextGeneratedHeaderSet(&context);
 
     string buffer;
diff --git a/net/spdy/fuzzing/hpack_fuzz_util.cc b/net/spdy/fuzzing/hpack_fuzz_util.cc
index 29604fe..038d71b 100644
--- a/net/spdy/fuzzing/hpack_fuzz_util.cc
+++ b/net/spdy/fuzzing/hpack_fuzz_util.cc
@@ -72,9 +72,9 @@ void HpackFuzzUtil::InitializeGeneratorContext(GeneratorContext* context) {
 }
 
 // static
-map<string, string> HpackFuzzUtil::NextGeneratedHeaderSet(
+SpdyHeaderBlock HpackFuzzUtil::NextGeneratedHeaderSet(
     GeneratorContext* context) {
-  map<string, string> headers;
+  SpdyHeaderBlock headers;
 
   size_t header_count = 1 + SampleExponential(kHeaderCountMean,
                                               kHeaderCountMax);
diff --git a/net/spdy/fuzzing/hpack_fuzz_util.h b/net/spdy/fuzzing/hpack_fuzz_util.h
index 18a5f33..df33a93 100644
--- a/net/spdy/fuzzing/hpack_fuzz_util.h
+++ b/net/spdy/fuzzing/hpack_fuzz_util.h
@@ -31,8 +31,7 @@ class NET_EXPORT_PRIVATE HpackFuzzUtil {
   static void InitializeGeneratorContext(GeneratorContext* context);
 
   // Generates a header set from the generator context.
-  static std::map<std::string, std::string> NextGeneratedHeaderSet(
-      GeneratorContext* context);
+  static SpdyHeaderBlock NextGeneratedHeaderSet(GeneratorContext* context);
 
   // Samples a size from the exponential distribution with mean |mean|,
   // upper-bounded by |sanity_bound|.
diff --git a/net/spdy/fuzzing/hpack_fuzz_util_test.cc b/net/spdy/fuzzing/hpack_fuzz_util_test.cc
index bf93def..6dace20 100644
--- a/net/spdy/fuzzing/hpack_fuzz_util_test.cc
+++ b/net/spdy/fuzzing/hpack_fuzz_util_test.cc
@@ -35,7 +35,7 @@ TEST(HpackFuzzUtilTest, GeneratorContextInitialization) {
 TEST(HpackFuzzUtil, GeneratorContextExpansion) {
   HpackFuzzUtil::GeneratorContext context;
 
-  map<string, string> headers = HpackFuzzUtil::NextGeneratedHeaderSet(&context);
+  SpdyHeaderBlock headers = HpackFuzzUtil::NextGeneratedHeaderSet(&context);
 
   // Headers were generated, and the generator context was expanded.
   EXPECT_LT(0u, headers.size());
@@ -104,7 +104,7 @@ TEST(HpackFuzzUtilTest, PassValidInputThroughAllStages) {
   EXPECT_TRUE(
       HpackFuzzUtil::RunHeaderBlockThroughFuzzerStages(&context, input));
 
-  std::map<string, string> expect;
+  SpdyHeaderBlock expect;
   expect[":method"] = "GET";
   expect[":scheme"] = "http";
   expect[":path"] = "/";
diff --git a/net/spdy/hpack_decoder.cc b/net/spdy/hpack_decoder.cc
index a5852ff..acf014b 100644
--- a/net/spdy/hpack_decoder.cc
+++ b/net/spdy/hpack_decoder.cc
@@ -4,6 +4,8 @@
 
 #include "net/spdy/hpack_decoder.h"
 
+#include <utility>
+
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "net/spdy/hpack_constants.h"
@@ -64,7 +66,7 @@ bool HpackDecoder::HandleControlFrameHeadersComplete(SpdyStreamId id) {
 
 bool HpackDecoder::HandleHeaderRepresentation(StringPiece name,
                                               StringPiece value) {
-  typedef std::pair<std::map<string, string>::iterator, bool> InsertResult;
+  typedef std::pair<SpdyHeaderBlock::iterator, bool> InsertResult;
 
   // Fail if pseudo-header follows regular header.
   if (name.size() > 0) {
diff --git a/net/spdy/hpack_decoder.h b/net/spdy/hpack_decoder.h
index a974058..4eb46de 100644
--- a/net/spdy/hpack_decoder.h
+++ b/net/spdy/hpack_decoder.h
@@ -63,9 +63,7 @@ class NET_EXPORT_PRIVATE HpackDecoder {
   // TODO(jgraettinger): This was added to facilitate re-encoding the block in
   // SPDY3 format for delivery to the SpdyFramer visitor, and will be removed
   // with the migration to SpdyHeadersHandlerInterface.
-  const std::map<std::string, std::string>& decoded_block() {
-    return decoded_block_;
-  }
+  const SpdyHeaderBlock& decoded_block() { return decoded_block_; }
 
  private:
   // Adds the header representation to |decoded_block_|, applying the
@@ -96,7 +94,7 @@ class NET_EXPORT_PRIVATE HpackDecoder {
   // processed headers block. Both will be removed with the switch to
   // SpdyHeadersHandlerInterface.
   std::string headers_block_buffer_;
-  std::map<std::string, std::string> decoded_block_;
+  SpdyHeaderBlock decoded_block_;
 
   // Flag to keep track of having seen a regular header field.
   bool regular_header_seen_;
diff --git a/net/spdy/hpack_decoder_test.cc b/net/spdy/hpack_decoder_test.cc
index 92dbbf2..1db1877 100644
--- a/net/spdy/hpack_decoder_test.cc
+++ b/net/spdy/hpack_decoder_test.cc
@@ -44,7 +44,7 @@ class HpackDecoderPeer {
   string cookie_value() {
     return decoder_->cookie_value_;
   }
-  const std::map<string, string>& decoded_block() const {
+  const SpdyHeaderBlock& decoded_block() const {
     return decoder_->decoded_block_;
   }
   const string& headers_block_buffer() const {
@@ -79,13 +79,13 @@ class HpackDecoderTest : public ::testing::Test {
         decoder_.HandleControlFrameHeadersComplete(0);
   }
 
-  const std::map<string, string>& decoded_block() const {
+  const SpdyHeaderBlock& decoded_block() const {
     // TODO(jgraettinger): HpackDecoderTest should implement
     // SpdyHeadersHandlerInterface, and collect headers for examination.
     return decoder_peer_.decoded_block();
   }
 
-  const std::map<string, string>& DecodeBlockExpectingSuccess(StringPiece str) {
+  const SpdyHeaderBlock& DecodeBlockExpectingSuccess(StringPiece str) {
     EXPECT_TRUE(DecodeHeaderBlock(str));
     return decoded_block();
   }
@@ -212,41 +212,38 @@ TEST_F(HpackDecoderTest, DecodeNextNameInvalidIndex) {
 // Decoding indexed static table field should work.
 TEST_F(HpackDecoderTest, IndexedHeaderStatic) {
   // Reference static table entries #2 and #5.
-  std::map<string, string> header_set1 =
-      DecodeBlockExpectingSuccess("\x82\x85");
-  std::map<string, string> expected_header_set1;
+  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.
-  std::map<string, string> header_set2 =
-      DecodeBlockExpectingSuccess("\x82");
-  std::map<string, string> expected_header_set2;
+  SpdyHeaderBlock header_set2 = DecodeBlockExpectingSuccess("\x82");
+  SpdyHeaderBlock expected_header_set2;
   expected_header_set2[":method"] = "GET";
   EXPECT_EQ(expected_header_set2, header_set2);
 }
 
 TEST_F(HpackDecoderTest, IndexedHeaderDynamic) {
   // First header block: add an entry to header table.
-  std::map<string, string> header_set1 =
+  SpdyHeaderBlock header_set1 =
       DecodeBlockExpectingSuccess("\x40\x03" "foo" "\x03" "bar");
-  std::map<string, string> expected_header_set1;
+  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.
-  std::map<string, string> header_set2 =
+  SpdyHeaderBlock header_set2 =
       DecodeBlockExpectingSuccess("\xbe\x40\x04" "spam" "\x04" "eggs");
-  std::map<string, string> expected_header_set2;
+  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.
-  std::map<string, string> header_set3 =
-      DecodeBlockExpectingSuccess("\xbe");
-  std::map<string, string> expected_header_set3;
+  SpdyHeaderBlock header_set3 = DecodeBlockExpectingSuccess("\xbe");
+  SpdyHeaderBlock expected_header_set3;
   expected_header_set3["spam"] = "eggs";
   EXPECT_EQ(expected_header_set3, header_set3);
 }
@@ -318,10 +315,10 @@ TEST_F(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";
-  std::map<string, string> header_set =
+  SpdyHeaderBlock header_set =
       DecodeBlockExpectingSuccess(StringPiece(input, arraysize(input) - 1));
 
-  std::map<string, string> expected_header_set;
+  SpdyHeaderBlock expected_header_set;
   expected_header_set[":path"] = "/sample/path";
   expected_header_set[":path2"] = "/sample/path/2";
   EXPECT_EQ(expected_header_set, header_set);
@@ -331,10 +328,10 @@ TEST_F(HpackDecoderTest, LiteralHeaderNoIndexing) {
 // indexing and string literal names should work.
 TEST_F(HpackDecoderTest, LiteralHeaderIncrementalIndexing) {
   const char input[] = "\x44\x0c/sample/path\x40\x06:path2\x0e/sample/path/2";
-  std::map<string, string> header_set =
+  SpdyHeaderBlock header_set =
       DecodeBlockExpectingSuccess(StringPiece(input, arraysize(input) - 1));
 
-  std::map<string, string> expected_header_set;
+  SpdyHeaderBlock expected_header_set;
   expected_header_set[":path"] = "/sample/path";
   expected_header_set[":path2"] = "/sample/path/2";
   EXPECT_EQ(expected_header_set, header_set);
@@ -367,7 +364,7 @@ TEST_F(HpackDecoderTest, LiteralHeaderNeverIndexedInvalidNameIndex) {
 TEST_F(HpackDecoderTest, BasicE21) {
   HpackEncoder encoder(ObtainHpackHuffmanTable());
 
-  std::map<string, string> expected_header_set;
+  SpdyHeaderBlock expected_header_set;
   expected_header_set[":method"] = "GET";
   expected_header_set[":scheme"] = "http";
   expected_header_set[":path"] = "/";
@@ -382,7 +379,7 @@ TEST_F(HpackDecoderTest, BasicE21) {
 }
 
 TEST_F(HpackDecoderTest, SectionD4RequestHuffmanExamples) {
-  std::map<string, string> header_set;
+  SpdyHeaderBlock header_set;
 
   // 82                                      | == Indexed - Add ==
   //                                         |   idx = 2
@@ -493,7 +490,7 @@ TEST_F(HpackDecoderTest, SectionD4RequestHuffmanExamples) {
 }
 
 TEST_F(HpackDecoderTest, SectionD6ResponseHuffmanExamples) {
-  std::map<string, string> header_set;
+  SpdyHeaderBlock header_set;
   decoder_.ApplyHeaderTableSizeSetting(256);
 
   // 48                                      | == Literal indexed ==
diff --git a/net/spdy/hpack_encoder.cc b/net/spdy/hpack_encoder.cc
index d8b5005d..10fbb86 100644
--- a/net/spdy/hpack_encoder.cc
+++ b/net/spdy/hpack_encoder.cc
@@ -25,7 +25,7 @@ HpackEncoder::HpackEncoder(const HpackHuffmanTable& table)
 
 HpackEncoder::~HpackEncoder() {}
 
-bool HpackEncoder::EncodeHeaderSet(const std::map<string, string>& header_set,
+bool HpackEncoder::EncodeHeaderSet(const SpdyHeaderBlock& header_set,
                                    string* output) {
   // Separate header set into pseudo-headers and regular headers.
   Representations pseudo_headers;
@@ -78,9 +78,8 @@ bool HpackEncoder::EncodeHeaderSet(const std::map<string, string>& header_set,
 }
 
 bool HpackEncoder::EncodeHeaderSetWithoutCompression(
-    const std::map<string, string>& header_set,
+    const SpdyHeaderBlock& header_set,
     string* output) {
-
   allow_huffman_compression_ = false;
   for (const auto& header : header_set) {
     // Note that cookies are not crumbled in this case.
diff --git a/net/spdy/hpack_encoder.h b/net/spdy/hpack_encoder.h
index 752f2f5..07e7088 100644
--- a/net/spdy/hpack_encoder.h
+++ b/net/spdy/hpack_encoder.h
@@ -16,6 +16,7 @@
 #include "net/base/net_export.h"
 #include "net/spdy/hpack_header_table.h"
 #include "net/spdy/hpack_output_stream.h"
+#include "net/spdy/spdy_protocol.h"
 
 // An HpackEncoder encodes header sets as outlined in
 // http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-08
@@ -39,15 +40,13 @@ class NET_EXPORT_PRIVATE HpackEncoder {
 
   // Encodes the given header set into the given string. Returns
   // whether or not the encoding was successful.
-  bool EncodeHeaderSet(const std::map<std::string, std::string>& header_set,
-                       std::string* output);
+  bool EncodeHeaderSet(const SpdyHeaderBlock& header_set, std::string* output);
 
   // Encodes the given header set into the given string. Only non-indexed
   // literal representations are emitted, bypassing the header table. Huffman
   // coding is also not used. Returns whether the encoding was successful.
-  bool EncodeHeaderSetWithoutCompression(
-      const std::map<std::string, std::string>& header_set,
-      std::string* output);
+  bool EncodeHeaderSetWithoutCompression(const SpdyHeaderBlock& header_set,
+                                         std::string* output);
 
   // Called upon a change to SETTINGS_HEADER_TABLE_SIZE. Specifically, this
   // is to be called after receiving (and sending an acknowledgement for) a
diff --git a/net/spdy/hpack_encoder_test.cc b/net/spdy/hpack_encoder_test.cc
index 43acfc4..5abe49f 100644
--- a/net/spdy/hpack_encoder_test.cc
+++ b/net/spdy/hpack_encoder_test.cc
@@ -145,7 +145,7 @@ class HpackEncoderTest : public ::testing::Test {
     expected_.AppendUint32(value.size());
     expected_.AppendBytes(value);
   }
-  void CompareWithExpectedEncoding(const map<string, string>& header_set) {
+  void CompareWithExpectedEncoding(const SpdyHeaderBlock& header_set) {
     string expected_out, actual_out;
     expected_.TakeString(&expected_out);
     EXPECT_TRUE(encoder_.EncodeHeaderSet(header_set, &actual_out));
@@ -170,7 +170,7 @@ class HpackEncoderTest : public ::testing::Test {
 TEST_F(HpackEncoderTest, SingleDynamicIndex) {
   ExpectIndex(IndexOf(key_2_));
 
-  map<string, string> headers;
+  SpdyHeaderBlock headers;
   headers[key_2_->name()] = key_2_->value();
   CompareWithExpectedEncoding(headers);
 }
@@ -178,7 +178,7 @@ TEST_F(HpackEncoderTest, SingleDynamicIndex) {
 TEST_F(HpackEncoderTest, SingleStaticIndex) {
   ExpectIndex(IndexOf(static_));
 
-  map<string, string> headers;
+  SpdyHeaderBlock headers;
   headers[static_->name()] = static_->value();
   CompareWithExpectedEncoding(headers);
 }
@@ -187,7 +187,7 @@ TEST_F(HpackEncoderTest, SingleStaticIndexTooLarge) {
   peer_.table()->SetMaxSize(1);  // Also evicts all fixtures.
   ExpectIndex(IndexOf(static_));
 
-  map<string, string> headers;
+  SpdyHeaderBlock headers;
   headers[static_->name()] = static_->value();
   CompareWithExpectedEncoding(headers);
 
@@ -197,7 +197,7 @@ TEST_F(HpackEncoderTest, SingleStaticIndexTooLarge) {
 TEST_F(HpackEncoderTest, SingleLiteralWithIndexName) {
   ExpectIndexedLiteral(key_2_, "value3");
 
-  map<string, string> headers;
+  SpdyHeaderBlock headers;
   headers[key_2_->name()] = "value3";
   CompareWithExpectedEncoding(headers);
 
@@ -210,7 +210,7 @@ TEST_F(HpackEncoderTest, SingleLiteralWithIndexName) {
 TEST_F(HpackEncoderTest, SingleLiteralWithLiteralName) {
   ExpectIndexedLiteral("key3", "value3");
 
-  map<string, string> headers;
+  SpdyHeaderBlock headers;
   headers["key3"] = "value3";
   CompareWithExpectedEncoding(headers);
 
@@ -226,7 +226,7 @@ TEST_F(HpackEncoderTest, SingleLiteralTooLarge) {
 
   // A header overflowing the header table is still emitted.
   // The header table is empty.
-  map<string, string> headers;
+  SpdyHeaderBlock headers;
   headers["key3"] = "value3";
   CompareWithExpectedEncoding(headers);
 
@@ -239,7 +239,7 @@ TEST_F(HpackEncoderTest, EmitThanEvict) {
   ExpectIndex(IndexOf(key_1_));
   ExpectIndexedLiteral("key3", "value3");
 
-  map<string, string> headers;
+  SpdyHeaderBlock headers;
   headers[key_1_->name()] = key_1_->value();
   headers["key3"] = "value3";
   CompareWithExpectedEncoding(headers);
@@ -250,7 +250,7 @@ TEST_F(HpackEncoderTest, CookieHeaderIsCrumbled) {
   ExpectIndex(IndexOf(cookie_c_));
   ExpectIndexedLiteral(peer_.table()->GetByName("cookie"), "e=ff");
 
-  map<string, string> headers;
+  SpdyHeaderBlock headers;
   headers["cookie"] = "e=ff; a=bb; c=dd";
   CompareWithExpectedEncoding(headers);
 }
@@ -284,7 +284,7 @@ TEST_F(HpackEncoderTest, EncodingWithoutCompression) {
   ExpectNonIndexedLiteral("cookie", "foo=bar; baz=bing");
   ExpectNonIndexedLiteral("hello", "goodbye");
 
-  map<string, string> headers;
+  SpdyHeaderBlock headers;
   headers[":path"] = "/index.html";
   headers["cookie"] = "foo=bar; baz=bing";
   headers["hello"] = "goodbye";
@@ -298,7 +298,7 @@ TEST_F(HpackEncoderTest, EncodingWithoutCompression) {
 TEST_F(HpackEncoderTest, MultipleEncodingPasses) {
   // Pass 1.
   {
-    map<string, string> headers;
+    SpdyHeaderBlock headers;
     headers["key1"] = "value1";
     headers["cookie"] = "a=bb";
 
@@ -313,7 +313,7 @@ TEST_F(HpackEncoderTest, MultipleEncodingPasses) {
   // 62: cookie: c=dd
   // Pass 2.
   {
-    map<string, string> headers;
+    SpdyHeaderBlock headers;
     headers["key2"] = "value2";
     headers["cookie"] = "c=dd; e=ff";
 
@@ -332,7 +332,7 @@ TEST_F(HpackEncoderTest, MultipleEncodingPasses) {
   // 62: cookie: e=ff
   // Pass 3.
   {
-    map<string, string> headers;
+    SpdyHeaderBlock headers;
     headers["key2"] = "value2";
     headers["cookie"] = "a=bb; b=cc; c=dd";
 
@@ -350,7 +350,7 @@ TEST_F(HpackEncoderTest, MultipleEncodingPasses) {
 }
 
 TEST_F(HpackEncoderTest, PseudoHeadersFirst) {
-  map<string, string> headers;
+  SpdyHeaderBlock headers;
   // A pseudo-header to be indexed.
   headers[":authority"] = "www.example.com";
   // A pseudo-header that should not be indexed.
@@ -448,7 +448,7 @@ TEST_F(HpackEncoderTest, DecomposeRepresentation) {
 // Test that encoded headers do not have \0-delimited multiple values, as this
 // became disallowed in HTTP/2 draft-14.
 TEST_F(HpackEncoderTest, CrumbleNullByteDelimitedValue) {
-  map<string, string> headers;
+  SpdyHeaderBlock headers;
   // A header field to be crumbled: "spam: foo\0bar".
   headers["spam"] = string("foo\0bar", 7);
 
diff --git a/net/spdy/hpack_round_trip_test.cc b/net/spdy/hpack_round_trip_test.cc
index fe97878..be79925 100644
--- a/net/spdy/hpack_round_trip_test.cc
+++ b/net/spdy/hpack_round_trip_test.cc
@@ -34,7 +34,7 @@ class HpackRoundTripTest : public ::testing::Test {
     decoder_.ApplyHeaderTableSizeSetting(256);
   }
 
-  bool RoundTrip(const map<string, string>& header_set) {
+  bool RoundTrip(const SpdyHeaderBlock& header_set) {
     string encoded;
     encoder_.EncodeHeaderSet(header_set, &encoded);
 
@@ -57,7 +57,7 @@ class HpackRoundTripTest : public ::testing::Test {
 
 TEST_F(HpackRoundTripTest, ResponseFixtures) {
   {
-    map<string, string> headers;
+    SpdyHeaderBlock headers;
     headers[":status"] = "302";
     headers["cache-control"] = "private";
     headers["date"] = "Mon, 21 Oct 2013 20:13:21 GMT";
@@ -65,7 +65,7 @@ TEST_F(HpackRoundTripTest, ResponseFixtures) {
     EXPECT_TRUE(RoundTrip(headers));
   }
   {
-    map<string, string> headers;
+    SpdyHeaderBlock headers;
     headers[":status"] = "200";
     headers["cache-control"] = "private";
     headers["date"] = "Mon, 21 Oct 2013 20:13:21 GMT";
@@ -73,7 +73,7 @@ TEST_F(HpackRoundTripTest, ResponseFixtures) {
     EXPECT_TRUE(RoundTrip(headers));
   }
   {
-    map<string, string> headers;
+    SpdyHeaderBlock headers;
     headers[":status"] = "200";
     headers["cache-control"] = "private";
     headers["content-encoding"] = "gzip";
@@ -88,7 +88,7 @@ TEST_F(HpackRoundTripTest, ResponseFixtures) {
 
 TEST_F(HpackRoundTripTest, RequestFixtures) {
   {
-    map<string, string> headers;
+    SpdyHeaderBlock headers;
     headers[":authority"] = "www.example.com";
     headers[":method"] = "GET";
     headers[":path"] = "/";
@@ -97,7 +97,7 @@ TEST_F(HpackRoundTripTest, RequestFixtures) {
     EXPECT_TRUE(RoundTrip(headers));
   }
   {
-    map<string, string> headers;
+    SpdyHeaderBlock headers;
     headers[":authority"] = "www.example.com";
     headers[":method"] = "GET";
     headers[":path"] = "/";
@@ -107,7 +107,7 @@ TEST_F(HpackRoundTripTest, RequestFixtures) {
     EXPECT_TRUE(RoundTrip(headers));
   }
   {
-    map<string, string> headers;
+    SpdyHeaderBlock headers;
     headers[":authority"] = "www.example.com";
     headers[":method"] = "GET";
     headers[":path"] = "/index.html";
@@ -144,7 +144,7 @@ TEST_F(HpackRoundTripTest, RandomizedExamples) {
   srand(seed);
 
   for (size_t i = 0; i != 2000; ++i) {
-    map<string, string> headers;
+    SpdyHeaderBlock headers;
 
     size_t header_count = 1 + SampleExponential(7, 50);
     for (size_t j = 0; j != header_count; ++j) {
diff --git a/net/spdy/spdy_framer.cc b/net/spdy/spdy_framer.cc
index b21419a..e454443 100644
--- a/net/spdy/spdy_framer.cc
+++ b/net/spdy/spdy_framer.cc
@@ -232,7 +232,7 @@ size_t SpdyFramer::GetControlFrameHeaderSize() const {
 
 size_t SpdyFramer::GetSynStreamMinimumSize() const {
   // Size, in bytes, of a SYN_STREAM frame not including the variable-length
-  // name-value block.
+  // header block.
   if (protocol_version() <= SPDY3) {
     // Calculated as:
     // control frame header + 2 * 4 (stream IDs) + 1 (priority)
@@ -247,7 +247,7 @@ size_t SpdyFramer::GetSynStreamMinimumSize() const {
 
 size_t SpdyFramer::GetSynReplyMinimumSize() const {
   // Size, in bytes, of a SYN_REPLY frame not including the variable-length
-  // name-value block.
+  // header block.
   size_t size = GetControlFrameHeaderSize();
   if (protocol_version() <= SPDY3) {
     // Calculated as:
@@ -318,7 +318,7 @@ size_t SpdyFramer::GetGoAwayMinimumSize() const {
 
 size_t SpdyFramer::GetHeadersMinimumSize() const  {
   // Size, in bytes, of a HEADERS frame not including the variable-length
-  // name-value block.
+  // header block.
   size_t size = GetControlFrameHeaderSize();
   if (protocol_version() <= SPDY3) {
     // Calculated as:
@@ -1201,13 +1201,11 @@ size_t SpdyFramer::GetSerializedLength(
   const size_t length_of_value_size = num_name_value_pairs_size;
 
   size_t total_length = num_name_value_pairs_size;
-  for (SpdyHeaderBlock::const_iterator it = headers->begin();
-       it != headers->end();
-       ++it) {
+  for (const auto& header : *headers) {
     // We add space for the length of the name and the length of the value as
     // well as the length of the name and the length of the value.
-    total_length += length_of_name_size + it->first.size() +
-                    length_of_value_size + it->second.size();
+    total_length += length_of_name_size + header.first.size() +
+                    length_of_value_size + header.second.size();
   }
   return total_length;
 }
@@ -1761,7 +1759,7 @@ void SpdyFramer::DeliverHpackBlockAsSpdy3Block() {
   DCHECK_LT(SPDY3, protocol_version());
   DCHECK_EQ(remaining_padding_payload_length_, remaining_data_length_);
 
-  const SpdyNameValueBlock& block = GetHpackDecoder()->decoded_block();
+  const SpdyHeaderBlock& block = GetHpackDecoder()->decoded_block();
   if (block.empty()) {
     // Special-case this to make tests happy.
     ProcessControlFrameHeaderBlock(NULL, 0, false);
@@ -1771,7 +1769,7 @@ void SpdyFramer::DeliverHpackBlockAsSpdy3Block() {
       GetSerializedLength(protocol_version(), &block),
       SPDY3);
 
-  SerializeNameValueBlockWithoutCompression(&builder, block);
+  SerializeHeaderBlockWithoutCompression(&builder, block);
   scoped_ptr<SpdyFrame> frame(builder.take());
 
   // Preserve padding length, and reset it after the re-entrant call.
@@ -2347,9 +2345,9 @@ SpdySerializedFrame* SpdyFramer::SerializeSynStream(
     priority = GetLowestPriority();
   }
 
-  // The size of this frame, including variable-length name-value block.
+  // The size of this frame, including variable-length header block.
   size_t size = GetSynStreamMinimumSize() +
-      GetSerializedLength(syn_stream.name_value_block());
+                GetSerializedLength(syn_stream.header_block());
 
   SpdyFrameBuilder builder(size, protocol_version());
   builder.WriteControlFrameHeader(*this, SYN_STREAM, flags);
@@ -2358,12 +2356,11 @@ SpdySerializedFrame* SpdyFramer::SerializeSynStream(
   builder.WriteUInt8(priority << ((protocol_version() <= SPDY2) ? 6 : 5));
   builder.WriteUInt8(0);  // Unused byte where credential slot used to be.
   DCHECK_EQ(GetSynStreamMinimumSize(), builder.length());
-  SerializeNameValueBlock(&builder, syn_stream);
+  SerializeHeaderBlock(&builder, syn_stream);
 
   if (debug_visitor_) {
     const size_t payload_len =
-        GetSerializedLength(protocol_version(),
-                            &(syn_stream.name_value_block()));
+        GetSerializedLength(protocol_version(), &(syn_stream.header_block()));
     debug_visitor_->OnSendCompressedFrame(syn_stream.stream_id(),
                                           SYN_STREAM,
                                           payload_len,
@@ -2381,9 +2378,9 @@ SpdySerializedFrame* SpdyFramer::SerializeSynReply(
     flags |= CONTROL_FLAG_FIN;
   }
 
-  // The size of this frame, including variable-length name-value block.
-  const size_t size = GetSynReplyMinimumSize() +
-                      GetSerializedLength(syn_reply.name_value_block());
+  // The size of this frame, including variable-length header block.
+  const size_t size =
+      GetSynReplyMinimumSize() + GetSerializedLength(syn_reply.header_block());
 
   SpdyFrameBuilder builder(size, protocol_version());
   if (protocol_version() <= SPDY3) {
@@ -2399,11 +2396,11 @@ SpdySerializedFrame* SpdyFramer::SerializeSynReply(
     builder.WriteUInt16(0);  // Unused.
   }
   DCHECK_EQ(GetSynReplyMinimumSize(), builder.length());
-  SerializeNameValueBlock(&builder, syn_reply);
+  SerializeHeaderBlock(&builder, syn_reply);
 
   if (debug_visitor_) {
-    const size_t payload_len = GetSerializedLength(
-        protocol_version(), &(syn_reply.name_value_block()));
+    const size_t payload_len =
+        GetSerializedLength(protocol_version(), &(syn_reply.header_block()));
     debug_visitor_->OnSendCompressedFrame(syn_reply.stream_id(),
                                           SYN_REPLY,
                                           payload_len,
@@ -2579,8 +2576,8 @@ SpdySerializedFrame* SpdyFramer::SerializeHeaders(
     }
   }
 
-  // The size of this frame, including padding (if there is any)
-  // and variable-length name-value block.
+  // The size of this frame, including padding (if there is any) and
+  // variable-length header block.
   size_t size = GetHeadersMinimumSize();
 
   if (protocol_version() > SPDY3 && headers.padded()) {
@@ -2600,11 +2597,11 @@ SpdySerializedFrame* SpdyFramer::SerializeHeaders(
   string hpack_encoding;
   if (protocol_version() > SPDY3) {
     if (enable_compression_) {
-      GetHpackEncoder()->EncodeHeaderSet(
-          headers.name_value_block(), &hpack_encoding);
+      GetHpackEncoder()->EncodeHeaderSet(headers.header_block(),
+                                         &hpack_encoding);
     } else {
       GetHpackEncoder()->EncodeHeaderSetWithoutCompression(
-          headers.name_value_block(), &hpack_encoding);
+          headers.header_block(), &hpack_encoding);
     }
     size += hpack_encoding.size();
     if (size > kMaxControlFrameSize) {
@@ -2613,7 +2610,7 @@ SpdySerializedFrame* SpdyFramer::SerializeHeaders(
       flags &= ~HEADERS_FLAG_END_HEADERS;
     }
   } else {
-    size += GetSerializedLength(headers.name_value_block());
+    size += GetSerializedLength(headers.header_block());
   }
 
   SpdyFrameBuilder builder(size, protocol_version());
@@ -2648,7 +2645,7 @@ SpdySerializedFrame* SpdyFramer::SerializeHeaders(
                                  HEADERS,
                                  padding_payload_len);
   } else {
-    SerializeNameValueBlock(&builder, headers);
+    SerializeHeaderBlock(&builder, headers);
   }
 
   if (debug_visitor_) {
@@ -2656,8 +2653,7 @@ SpdySerializedFrame* SpdyFramer::SerializeHeaders(
     // use GetSerializedLength() for an apples-to-apples comparision of
     // compression performance between HPACK and SPDY w/ deflate.
     const size_t payload_len =
-        GetSerializedLength(protocol_version(),
-                            &(headers.name_value_block()));
+        GetSerializedLength(protocol_version(), &(headers.header_block()));
     debug_visitor_->OnSendCompressedFrame(headers.stream_id(),
                                           HEADERS,
                                           payload_len,
@@ -2708,11 +2704,11 @@ SpdyFrame* SpdyFramer::SerializePushPromise(
 
   string hpack_encoding;
   if (enable_compression_) {
-    GetHpackEncoder()->EncodeHeaderSet(
-        push_promise.name_value_block(), &hpack_encoding);
+    GetHpackEncoder()->EncodeHeaderSet(push_promise.header_block(),
+                                       &hpack_encoding);
   } else {
     GetHpackEncoder()->EncodeHeaderSetWithoutCompression(
-        push_promise.name_value_block(), &hpack_encoding);
+        push_promise.header_block(), &hpack_encoding);
   }
   size += hpack_encoding.size();
   if (size > kMaxControlFrameSize) {
@@ -2750,8 +2746,7 @@ SpdyFrame* SpdyFramer::SerializePushPromise(
     // use GetSerializedLength() for an apples-to-apples comparision of
     // compression performance between HPACK and SPDY w/ deflate.
     const size_t payload_len =
-        GetSerializedLength(protocol_version(),
-                            &(push_promise.name_value_block()));
+        GetSerializedLength(protocol_version(), &(push_promise.header_block()));
     debug_visitor_->OnSendCompressedFrame(push_promise.stream_id(),
                                           PUSH_PROMISE,
                                           payload_len,
@@ -2776,11 +2771,11 @@ SpdyFrame* SpdyFramer::SerializeContinuation(
   size_t size = GetContinuationMinimumSize();
   string hpack_encoding;
   if (enable_compression_) {
-    GetHpackEncoder()->EncodeHeaderSet(
-        continuation.name_value_block(), &hpack_encoding);
+    GetHpackEncoder()->EncodeHeaderSet(continuation.header_block(),
+                                       &hpack_encoding);
   } else {
     GetHpackEncoder()->EncodeHeaderSetWithoutCompression(
-        continuation.name_value_block(), &hpack_encoding);
+        continuation.header_block(), &hpack_encoding);
   }
   size += hpack_encoding.size();
 
@@ -3152,45 +3147,42 @@ size_t SpdyFramer::header_table_size_bound() const {
   return header_table_size_bound_;
 }
 
-void SpdyFramer::SerializeNameValueBlockWithoutCompression(
+void SpdyFramer::SerializeHeaderBlockWithoutCompression(
     SpdyFrameBuilder* builder,
-    const SpdyNameValueBlock& name_value_block) const {
+    const SpdyHeaderBlock& header_block) const {
   // Serialize number of headers.
   if (protocol_version() <= SPDY2) {
-    builder->WriteUInt16(static_cast<uint16>(name_value_block.size()));
+    builder->WriteUInt16(static_cast<uint16>(header_block.size()));
   } else {
-    builder->WriteUInt32(name_value_block.size());
+    builder->WriteUInt32(header_block.size());
   }
 
   // Serialize each header.
-  for (SpdyHeaderBlock::const_iterator it = name_value_block.begin();
-       it != name_value_block.end();
-       ++it) {
+  for (const auto& header : header_block) {
     if (protocol_version() <= SPDY2) {
-      builder->WriteStringPiece16(it->first);
-      builder->WriteStringPiece16(it->second);
+      builder->WriteStringPiece16(header.first);
+      builder->WriteStringPiece16(header.second);
     } else {
-      builder->WriteStringPiece32(it->first);
-      builder->WriteStringPiece32(it->second);
+      builder->WriteStringPiece32(header.first);
+      builder->WriteStringPiece32(header.second);
     }
   }
 }
 
-void SpdyFramer::SerializeNameValueBlock(
-    SpdyFrameBuilder* builder,
-    const SpdyFrameWithNameValueBlockIR& frame) {
+void SpdyFramer::SerializeHeaderBlock(SpdyFrameBuilder* builder,
+                                      const SpdyFrameWithHeaderBlockIR& frame) {
   CHECK_GE(SPDY3, protocol_version());
   if (!enable_compression_) {
-    return SerializeNameValueBlockWithoutCompression(builder,
-                                                     frame.name_value_block());
+    return SerializeHeaderBlockWithoutCompression(builder,
+                                                  frame.header_block());
   }
 
   // First build an uncompressed version to be fed into the compressor.
-  const size_t uncompressed_len = GetSerializedLength(
-      protocol_version(), &(frame.name_value_block()));
+  const size_t uncompressed_len =
+      GetSerializedLength(protocol_version(), &(frame.header_block()));
   SpdyFrameBuilder uncompressed_builder(uncompressed_len, protocol_version());
-  SerializeNameValueBlockWithoutCompression(&uncompressed_builder,
-                                            frame.name_value_block());
+  SerializeHeaderBlockWithoutCompression(&uncompressed_builder,
+                                         frame.header_block());
   scoped_ptr<SpdyFrame> uncompressed_payload(uncompressed_builder.take());
 
   z_stream* compressor = GetHeaderCompressor();
@@ -3228,7 +3220,7 @@ void SpdyFramer::SerializeNameValueBlock(
     return;
   }
 #else
-  WriteHeaderBlockToZ(&frame.name_value_block(), compressor);
+  WriteHeaderBlockToZ(&frame.header_block(), compressor);
 #endif  // defined(USE_SYSTEM_ZLIB)
 
   int compressed_size = compressed_max_size - compressor->avail_out;
diff --git a/net/spdy/spdy_framer.h b/net/spdy/spdy_framer.h
index f7114c6..cbefef5 100644
--- a/net/spdy/spdy_framer.h
+++ b/net/spdy/spdy_framer.h
@@ -49,10 +49,6 @@ class SpdyFramerPeer;
 
 }  // namespace test
 
-// A datastructure for holding a set of headers from a HEADERS, PUSH_PROMISE,
-// SYN_STREAM, or SYN_REPLY frame.
-typedef std::map<std::string, std::string> SpdyHeaderBlock;
-
 // A datastructure for holding the ID and flag fields for SETTINGS.
 // Conveniently handles converstion to/from wire format.
 class NET_EXPORT_PRIVATE SettingsFlagsAndId {
@@ -676,14 +672,13 @@ class NET_EXPORT_PRIVATE SpdyFramer {
   void WriteHeaderBlockToZ(const SpdyHeaderBlock* headers,
                            z_stream* out) const;
 
-  void SerializeNameValueBlockWithoutCompression(
+  void SerializeHeaderBlockWithoutCompression(
       SpdyFrameBuilder* builder,
-      const SpdyNameValueBlock& name_value_block) const;
+      const SpdyHeaderBlock& header_block) const;
 
   // Compresses automatically according to enable_compression_.
-  void SerializeNameValueBlock(
-      SpdyFrameBuilder* builder,
-      const SpdyFrameWithNameValueBlockIR& frame);
+  void SerializeHeaderBlock(SpdyFrameBuilder* builder,
+                            const SpdyFrameWithHeaderBlockIR& frame);
 
   // Set the error code and moves the framer into the error state.
   void set_error(SpdyError error);
diff --git a/net/spdy/spdy_framer_test.cc b/net/spdy/spdy_framer_test.cc
index 00422d3..0269894 100644
--- a/net/spdy/spdy_framer_test.cc
+++ b/net/spdy/spdy_framer_test.cc
@@ -719,8 +719,7 @@ TEST_P(SpdyFramerTest, HeaderBlockWithEmptyCookie) {
       frame->size());
 
   EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
-  EXPECT_FALSE(CompareHeaderBlocks(&headers.name_value_block(),
-                                  &visitor.headers_));
+  EXPECT_FALSE(CompareHeaderBlocks(&headers.header_block(), &visitor.headers_));
   EXPECT_EQ(1u, visitor.headers_.size());
   EXPECT_EQ("key=value; foo; bar=; k2=v2 ", visitor.headers_["cookie"]);
 }
@@ -746,8 +745,7 @@ TEST_P(SpdyFramerTest, HeaderBlockInBuffer) {
       frame->size());
 
   EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
-  EXPECT_TRUE(CompareHeaderBlocks(&headers.name_value_block(),
-                                  &visitor.headers_));
+  EXPECT_TRUE(CompareHeaderBlocks(&headers.header_block(), &visitor.headers_));
 }
 
 // Test that if there's not a full frame, we fail to parse it.
@@ -970,7 +968,7 @@ TEST_P(SpdyFramerTest, MultiValueHeader) {
     frame.WriteStringPiece16(value);
   } else if (spdy_version_ > SPDY3) {
     // TODO(jgraettinger): If this pattern appears again, move to test class.
-    std::map<string, string> header_set;
+    SpdyHeaderBlock header_set;
     header_set["name"] = value;
     string buffer;
     HpackEncoder encoder(ObtainHpackHuffmanTable());
@@ -1508,14 +1506,14 @@ TEST_P(SpdyFramerTest, HeaderCompression) {
   block[kHeader1] = kValue1;
   block[kHeader2] = kValue2;
   SpdySynStreamIR syn_ir_1(1);
-  syn_ir_1.set_name_value_block(block);
+  syn_ir_1.set_header_block(block);
   scoped_ptr<SpdyFrame> syn_frame_1(send_framer.SerializeFrame(syn_ir_1));
   EXPECT_TRUE(syn_frame_1.get() != NULL);
 
   // SYN_STREAM #2
   block[kHeader3] = kValue3;
   SpdySynStreamIR syn_stream(3);
-  syn_stream.set_name_value_block(block);
+  syn_stream.set_header_block(block);
   scoped_ptr<SpdyFrame> syn_frame_2(send_framer.SerializeSynStream(syn_stream));
   EXPECT_TRUE(syn_frame_2.get() != NULL);
 
@@ -3582,7 +3580,7 @@ TEST_P(SpdyFramerTest, ReadCompressedSynStreamHeaderBlock) {
   syn_stream.set_priority(1);
   syn_stream.SetHeader("aa", "vv");
   syn_stream.SetHeader("bb", "ww");
-  SpdyHeaderBlock headers = syn_stream.name_value_block();
+  SpdyHeaderBlock headers = syn_stream.header_block();
   scoped_ptr<SpdyFrame> control_frame(framer.SerializeSynStream(syn_stream));
   EXPECT_TRUE(control_frame.get() != NULL);
   TestSpdyVisitor visitor(spdy_version_);
@@ -3602,7 +3600,7 @@ TEST_P(SpdyFramerTest, ReadCompressedSynReplyHeaderBlock) {
   SpdySynReplyIR syn_reply(1);
   syn_reply.SetHeader("alpha", "beta");
   syn_reply.SetHeader("gamma", "delta");
-  SpdyHeaderBlock headers = syn_reply.name_value_block();
+  SpdyHeaderBlock headers = syn_reply.header_block();
   scoped_ptr<SpdyFrame> control_frame(framer.SerializeSynReply(syn_reply));
   EXPECT_TRUE(control_frame.get() != NULL);
   TestSpdyVisitor visitor(spdy_version_);
@@ -3625,7 +3623,7 @@ TEST_P(SpdyFramerTest, ReadCompressedHeadersHeaderBlock) {
   SpdyHeadersIR headers_ir(1);
   headers_ir.SetHeader("alpha", "beta");
   headers_ir.SetHeader("gamma", "delta");
-  SpdyHeaderBlock headers = headers_ir.name_value_block();
+  SpdyHeaderBlock headers = headers_ir.header_block();
   scoped_ptr<SpdyFrame> control_frame(framer.SerializeHeaders(headers_ir));
   EXPECT_TRUE(control_frame.get() != NULL);
   TestSpdyVisitor visitor(spdy_version_);
@@ -3650,7 +3648,7 @@ TEST_P(SpdyFramerTest, ReadCompressedHeadersHeaderBlockWithHalfClose) {
   headers_ir.set_fin(true);
   headers_ir.SetHeader("alpha", "beta");
   headers_ir.SetHeader("gamma", "delta");
-  SpdyHeaderBlock headers = headers_ir.name_value_block();
+  SpdyHeaderBlock headers = headers_ir.header_block();
   scoped_ptr<SpdyFrame> control_frame(framer.SerializeHeaders(headers_ir));
   EXPECT_TRUE(control_frame.get() != NULL);
   TestSpdyVisitor visitor(spdy_version_);
@@ -4351,7 +4349,7 @@ TEST_P(SpdyFramerTest, ReadCompressedPushPromise) {
   SpdyPushPromiseIR push_promise(42, 57);
   push_promise.SetHeader("foo", "bar");
   push_promise.SetHeader("bar", "foofoo");
-  SpdyHeaderBlock headers = push_promise.name_value_block();
+  SpdyHeaderBlock headers = push_promise.header_block();
   scoped_ptr<SpdySerializedFrame> frame(
     framer.SerializePushPromise(push_promise));
   EXPECT_TRUE(frame.get() != NULL);
@@ -5593,7 +5591,7 @@ TEST_P(SpdyFramerTest, EmptySynStream) {
   SpdySynStreamIR syn_stream(1);
   syn_stream.set_priority(1);
   scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
-  // Adjust size to remove the name/value block.
+  // Adjust size to remove the header block.
   SetFrameLength(
       frame.get(),
       framer.GetSynStreamMinimumSize() - framer.GetControlFrameHeaderSize(),
diff --git a/net/spdy/spdy_protocol.cc b/net/spdy/spdy_protocol.cc
index 48a75c5..46b080f 100644
--- a/net/spdy/spdy_protocol.cc
+++ b/net/spdy/spdy_protocol.cc
@@ -6,10 +6,10 @@
 
 namespace net {
 
-SpdyFrameWithNameValueBlockIR::SpdyFrameWithNameValueBlockIR(
-    SpdyStreamId stream_id) : SpdyFrameWithFinIR(stream_id) {}
+SpdyFrameWithHeaderBlockIR::SpdyFrameWithHeaderBlockIR(SpdyStreamId stream_id)
+    : SpdyFrameWithFinIR(stream_id) {}
 
-SpdyFrameWithNameValueBlockIR::~SpdyFrameWithNameValueBlockIR() {}
+SpdyFrameWithHeaderBlockIR::~SpdyFrameWithHeaderBlockIR() {}
 
 SpdyDataIR::SpdyDataIR(SpdyStreamId stream_id, base::StringPiece data)
     : SpdyFrameWithFinIR(stream_id), padded_(false), padding_payload_len_(0) {
diff --git a/net/spdy/spdy_protocol.h b/net/spdy/spdy_protocol.h
index 8a8131e..322c613 100644
--- a/net/spdy/spdy_protocol.h
+++ b/net/spdy/spdy_protocol.h
@@ -420,7 +420,9 @@ enum SpdyGoAwayStatus {
 // number between 0 and 3.
 typedef uint8 SpdyPriority;
 
-typedef std::map<std::string, std::string> SpdyNameValueBlock;
+// A datastructure for holding a set of headers from a HEADERS, PUSH_PROMISE,
+// SYN_STREAM, or SYN_REPLY frame.
+typedef std::map<std::string, std::string> SpdyHeaderBlock;
 
 typedef uint64 SpdyPingId;
 
@@ -601,33 +603,29 @@ class NET_EXPORT_PRIVATE SpdyFrameWithFinIR : public SpdyFrameWithStreamIdIR {
   DISALLOW_COPY_AND_ASSIGN(SpdyFrameWithFinIR);
 };
 
-// Abstract class intended to be inherited by IRs that contain a name-value
+// Abstract class intended to be inherited by IRs that contain a header
 // block. Implies SpdyFrameWithFinIR.
-class NET_EXPORT_PRIVATE SpdyFrameWithNameValueBlockIR
+class NET_EXPORT_PRIVATE SpdyFrameWithHeaderBlockIR
     : public NON_EXPORTED_BASE(SpdyFrameWithFinIR) {
  public:
-  const SpdyNameValueBlock& name_value_block() const {
-    return name_value_block_;
-  }
-  void set_name_value_block(const SpdyNameValueBlock& name_value_block) {
+  const SpdyHeaderBlock& header_block() const { return header_block_; }
+  void set_header_block(const SpdyHeaderBlock& header_block) {
     // Deep copy.
-    name_value_block_ = name_value_block;
+    header_block_ = header_block;
   }
   void SetHeader(base::StringPiece name, base::StringPiece value) {
-    name_value_block_[name.as_string()] = value.as_string();
-  }
-  SpdyNameValueBlock* mutable_name_value_block() {
-    return &name_value_block_;
+    header_block_[name.as_string()] = value.as_string();
   }
+  SpdyHeaderBlock* mutable_header_block() { return &header_block_; }
 
  protected:
-  explicit SpdyFrameWithNameValueBlockIR(SpdyStreamId stream_id);
-  ~SpdyFrameWithNameValueBlockIR() override;
+  explicit SpdyFrameWithHeaderBlockIR(SpdyStreamId stream_id);
+  ~SpdyFrameWithHeaderBlockIR() override;
 
  private:
-  SpdyNameValueBlock name_value_block_;
+  SpdyHeaderBlock header_block_;
 
-  DISALLOW_COPY_AND_ASSIGN(SpdyFrameWithNameValueBlockIR);
+  DISALLOW_COPY_AND_ASSIGN(SpdyFrameWithHeaderBlockIR);
 };
 
 class NET_EXPORT_PRIVATE SpdyDataIR
@@ -681,11 +679,10 @@ class NET_EXPORT_PRIVATE SpdyDataIR
   DISALLOW_COPY_AND_ASSIGN(SpdyDataIR);
 };
 
-class NET_EXPORT_PRIVATE SpdySynStreamIR
-    : public SpdyFrameWithNameValueBlockIR {
+class NET_EXPORT_PRIVATE SpdySynStreamIR : public SpdyFrameWithHeaderBlockIR {
  public:
   explicit SpdySynStreamIR(SpdyStreamId stream_id)
-      : SpdyFrameWithNameValueBlockIR(stream_id),
+      : SpdyFrameWithHeaderBlockIR(stream_id),
         associated_to_stream_id_(0),
         priority_(0),
         unidirectional_(false) {}
@@ -712,10 +709,10 @@ class NET_EXPORT_PRIVATE SpdySynStreamIR
   DISALLOW_COPY_AND_ASSIGN(SpdySynStreamIR);
 };
 
-class NET_EXPORT_PRIVATE SpdySynReplyIR : public SpdyFrameWithNameValueBlockIR {
+class NET_EXPORT_PRIVATE SpdySynReplyIR : public SpdyFrameWithHeaderBlockIR {
  public:
   explicit SpdySynReplyIR(SpdyStreamId stream_id)
-      : SpdyFrameWithNameValueBlockIR(stream_id) {}
+      : SpdyFrameWithHeaderBlockIR(stream_id) {}
 
   void Visit(SpdyFrameVisitor* visitor) const override;
 
@@ -840,10 +837,10 @@ class NET_EXPORT_PRIVATE SpdyGoAwayIR : public SpdyFrameIR {
   DISALLOW_COPY_AND_ASSIGN(SpdyGoAwayIR);
 };
 
-class NET_EXPORT_PRIVATE SpdyHeadersIR : public SpdyFrameWithNameValueBlockIR {
+class NET_EXPORT_PRIVATE SpdyHeadersIR : public SpdyFrameWithHeaderBlockIR {
  public:
   explicit SpdyHeadersIR(SpdyStreamId stream_id)
-      : SpdyFrameWithNameValueBlockIR(stream_id) {}
+      : SpdyFrameWithHeaderBlockIR(stream_id) {}
 
   void Visit(SpdyFrameVisitor* visitor) const override;
 
@@ -910,11 +907,10 @@ class NET_EXPORT_PRIVATE SpdyBlockedIR
   DISALLOW_COPY_AND_ASSIGN(SpdyBlockedIR);
 };
 
-class NET_EXPORT_PRIVATE SpdyPushPromiseIR
-    : public SpdyFrameWithNameValueBlockIR {
+class NET_EXPORT_PRIVATE SpdyPushPromiseIR : public SpdyFrameWithHeaderBlockIR {
  public:
   SpdyPushPromiseIR(SpdyStreamId stream_id, SpdyStreamId promised_stream_id)
-      : SpdyFrameWithNameValueBlockIR(stream_id),
+      : SpdyFrameWithHeaderBlockIR(stream_id),
         promised_stream_id_(promised_stream_id),
         padded_(false),
         padding_payload_len_(0) {}
@@ -944,11 +940,10 @@ class NET_EXPORT_PRIVATE SpdyPushPromiseIR
 // TODO(jgraettinger): This representation needs review. SpdyContinuationIR
 // needs to frame a portion of a single, arbitrarily-broken encoded buffer.
 class NET_EXPORT_PRIVATE SpdyContinuationIR
-    : public SpdyFrameWithNameValueBlockIR {
+    : public SpdyFrameWithHeaderBlockIR {
  public:
   explicit SpdyContinuationIR(SpdyStreamId stream_id)
-      : SpdyFrameWithNameValueBlockIR(stream_id),
-        end_headers_(false) {}
+      : SpdyFrameWithHeaderBlockIR(stream_id), end_headers_(false) {}
 
   void Visit(SpdyFrameVisitor* visitor) const override;
 
diff --git a/net/spdy/spdy_session.cc b/net/spdy/spdy_session.cc
index f117ab2..ab7baf3 100644
--- a/net/spdy/spdy_session.cc
+++ b/net/spdy/spdy_session.cc
@@ -1076,14 +1076,14 @@ scoped_ptr<SpdyFrame> SpdySession::CreateSynStream(
     syn_stream.set_priority(spdy_priority);
     syn_stream.set_fin((flags & CONTROL_FLAG_FIN) != 0);
     syn_stream.set_unidirectional((flags & CONTROL_FLAG_UNIDIRECTIONAL) != 0);
-    syn_stream.set_name_value_block(block);
+    syn_stream.set_header_block(block);
     syn_frame.reset(buffered_spdy_framer_->SerializeFrame(syn_stream));
   } else {
     SpdyHeadersIR headers(stream_id);
     headers.set_priority(spdy_priority);
     headers.set_has_priority(true);
     headers.set_fin((flags & CONTROL_FLAG_FIN) != 0);
-    headers.set_name_value_block(block);
+    headers.set_header_block(block);
     syn_frame.reset(buffered_spdy_framer_->SerializeFrame(headers));
   }
 
diff --git a/net/spdy/spdy_test_util_common.cc b/net/spdy/spdy_test_util_common.cc
index 935e452..0d3e6b2 100644
--- a/net/spdy/spdy_test_util_common.cc
+++ b/net/spdy/spdy_test_util_common.cc
@@ -1001,22 +1001,21 @@ SpdyFrame* SpdyTestUtil::ConstructSpdyPush(const char* const extra_headers[],
     syn_stream.SetHeader("hello", "bye");
     syn_stream.SetHeader(GetStatusKey(), "200 OK");
     syn_stream.SetHeader(GetVersionKey(), "HTTP/1.1");
-    AddUrlToHeaderBlock(url, syn_stream.mutable_name_value_block());
-    AppendToHeaderBlock(extra_headers,
-                        extra_header_count,
-                        syn_stream.mutable_name_value_block());
+    AddUrlToHeaderBlock(url, syn_stream.mutable_header_block());
+    AppendToHeaderBlock(extra_headers, extra_header_count,
+                        syn_stream.mutable_header_block());
     return CreateFramer(false)->SerializeFrame(syn_stream);
   } else {
     SpdyPushPromiseIR push_promise(associated_stream_id, stream_id);
-    AddUrlToHeaderBlock(url, push_promise.mutable_name_value_block());
+    AddUrlToHeaderBlock(url, push_promise.mutable_header_block());
     scoped_ptr<SpdyFrame> push_promise_frame(
         CreateFramer(false)->SerializeFrame(push_promise));
 
     SpdyHeadersIR headers(stream_id);
     headers.SetHeader("hello", "bye");
     headers.SetHeader(GetStatusKey(), "200 OK");
-    AppendToHeaderBlock(
-        extra_headers, extra_header_count, headers.mutable_name_value_block());
+    AppendToHeaderBlock(extra_headers, extra_header_count,
+                        headers.mutable_header_block());
     scoped_ptr<SpdyFrame> headers_frame(
         CreateFramer(false)->SerializeFrame(headers));
 
@@ -1046,14 +1045,13 @@ SpdyFrame* SpdyTestUtil::ConstructSpdyPush(const char* const extra_headers[],
     syn_stream.SetHeader(GetStatusKey(), status);
     syn_stream.SetHeader(GetVersionKey(), "HTTP/1.1");
     syn_stream.SetHeader("location", location);
-    AddUrlToHeaderBlock(url, syn_stream.mutable_name_value_block());
-    AppendToHeaderBlock(extra_headers,
-                        extra_header_count,
-                        syn_stream.mutable_name_value_block());
+    AddUrlToHeaderBlock(url, syn_stream.mutable_header_block());
+    AppendToHeaderBlock(extra_headers, extra_header_count,
+                        syn_stream.mutable_header_block());
     return CreateFramer(false)->SerializeFrame(syn_stream);
   } else {
     SpdyPushPromiseIR push_promise(associated_stream_id, stream_id);
-    AddUrlToHeaderBlock(url, push_promise.mutable_name_value_block());
+    AddUrlToHeaderBlock(url, push_promise.mutable_header_block());
     scoped_ptr<SpdyFrame> push_promise_frame(
         CreateFramer(false)->SerializeFrame(push_promise));
 
@@ -1061,8 +1059,8 @@ SpdyFrame* SpdyTestUtil::ConstructSpdyPush(const char* const extra_headers[],
     headers.SetHeader("hello", "bye");
     headers.SetHeader(GetStatusKey(), status);
     headers.SetHeader("location", location);
-    AppendToHeaderBlock(
-        extra_headers, extra_header_count, headers.mutable_name_value_block());
+    AppendToHeaderBlock(extra_headers, extra_header_count,
+                        headers.mutable_header_block());
     scoped_ptr<SpdyFrame> headers_frame(
         CreateFramer(false)->SerializeFrame(headers));
 
@@ -1086,11 +1084,11 @@ SpdyFrame* SpdyTestUtil::ConstructInitialSpdyPushFrame(
     SpdySynStreamIR syn_stream(stream_id);
     syn_stream.set_associated_to_stream_id(associated_stream_id);
     SetPriority(LOWEST, &syn_stream);
-    syn_stream.set_name_value_block(*headers);
+    syn_stream.set_header_block(*headers);
     return CreateFramer(false)->SerializeFrame(syn_stream);
   } else {
     SpdyPushPromiseIR push_promise(associated_stream_id, stream_id);
-    push_promise.set_name_value_block(*headers);
+    push_promise.set_header_block(*headers);
     return CreateFramer(false)->SerializeFrame(push_promise);
   }
 }
@@ -1103,7 +1101,7 @@ SpdyFrame* SpdyTestUtil::ConstructSpdyPushHeaders(
   headers.SetHeader(GetStatusKey(), "200 OK");
   MaybeAddVersionHeader(&headers);
   AppendToHeaderBlock(extra_headers, extra_header_count,
-                      headers.mutable_name_value_block());
+                      headers.mutable_header_block());
   return CreateFramer(false)->SerializeFrame(headers);
 }
 
@@ -1114,14 +1112,14 @@ SpdyFrame* SpdyTestUtil::ConstructSpdySyn(int stream_id,
                                           bool fin) const {
   if (protocol_ < kProtoHTTP2MinimumVersion) {
     SpdySynStreamIR syn_stream(stream_id);
-    syn_stream.set_name_value_block(block);
+    syn_stream.set_header_block(block);
     syn_stream.set_priority(
         ConvertRequestPriorityToSpdyPriority(priority, spdy_version()));
     syn_stream.set_fin(fin);
     return CreateFramer(compressed)->SerializeFrame(syn_stream);
   } else {
     SpdyHeadersIR headers(stream_id);
-    headers.set_name_value_block(block);
+    headers.set_header_block(block);
     headers.set_has_priority(true);
     headers.set_priority(
         ConvertRequestPriorityToSpdyPriority(priority, spdy_version()));
@@ -1134,11 +1132,11 @@ SpdyFrame* SpdyTestUtil::ConstructSpdyReply(int stream_id,
                                             const SpdyHeaderBlock& headers) {
   if (protocol_ < kProtoHTTP2MinimumVersion) {
     SpdySynReplyIR syn_reply(stream_id);
-    syn_reply.set_name_value_block(headers);
+    syn_reply.set_header_block(headers);
     return CreateFramer(false)->SerializeFrame(syn_reply);
   } else {
     SpdyHeadersIR reply(stream_id);
-    reply.set_name_value_block(headers);
+    reply.set_header_block(headers);
     return CreateFramer(false)->SerializeFrame(reply);
   }
 }
@@ -1321,7 +1319,7 @@ scoped_ptr<SpdyHeaderBlock> SpdyTestUtil::ConstructHeaderBlock(
 }
 
 void SpdyTestUtil::MaybeAddVersionHeader(
-    SpdyFrameWithNameValueBlockIR* frame_ir) const {
+    SpdyFrameWithHeaderBlockIR* frame_ir) const {
   if (include_version_header()) {
     frame_ir->SetHeader(GetVersionKey(), "HTTP/1.1");
   }
diff --git a/net/spdy/spdy_test_util_common.h b/net/spdy/spdy_test_util_common.h
index ac37774..ae49bde 100644
--- a/net/spdy/spdy_test_util_common.h
+++ b/net/spdy/spdy_test_util_common.h
@@ -550,7 +550,7 @@ class SpdyTestUtil {
   const SpdyHeaderInfo MakeSpdyHeader(SpdyFrameType type);
 
   // For versions below SPDY4, adds the version HTTP/1.1 header.
-  void MaybeAddVersionHeader(SpdyFrameWithNameValueBlockIR* frame_ir) const;
+  void MaybeAddVersionHeader(SpdyFrameWithHeaderBlockIR* frame_ir) const;
   void MaybeAddVersionHeader(SpdyHeaderBlock* block) const;
 
   // Maps |priority| to SPDY version priority, and sets it on |frame_ir|.