Replace the existing SpdyHeaderBlock typedef with a class.

net/spdy/spdy_network_transaction_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_util.h"
@@ skipping 2976 matching lines @@
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   scoped_ptr<SpdyFrame> stream2_rst(
       spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_PROTOCOL_ERROR));
   MockWrite writes[] = {
       CreateMockWrite(*stream1_syn, 0), CreateMockWrite(*stream2_rst, 3),
   };
 
   scoped_ptr<SpdyFrame>
       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyHeaderBlock> incomplete_headers(new SpdyHeaderBlock());
-  (*incomplete_headers)["hello"] = "bye";
   (*incomplete_headers)[spdy_util_.GetStatusKey()] = "200 OK";
   (*incomplete_headers)[spdy_util_.GetVersionKey()] = "HTTP/1.1";
+  (*incomplete_headers)["hello"] = "bye";
   scoped_ptr<SpdyFrame> stream2_syn(spdy_util_.ConstructInitialSpdyPushFrame(
       incomplete_headers.Pass(), 2, 1));
   MockRead reads[] = {
       CreateMockRead(*stream1_reply, 1),
       CreateMockRead(*stream2_syn, 2),
       CreateMockRead(*stream1_body, 4),
       MockRead(SYNCHRONOUS, ERR_IO_PENDING, 5)  // Force a pause
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
@@ skipping 43 matching lines @@
       { NULL },
     },
     // Headers with a comma separated list.
     { 1,
       { "cookie", "val1,val2",
         NULL
       },
     }
   };
 
-  test_cases[0].expected_headers["cookie"] = "val1";
-  test_cases[0].expected_headers["cookie"] += '\0';
-  test_cases[0].expected_headers["cookie"] += "val2";
-  test_cases[0].expected_headers["hello"] = "bye";
   test_cases[0].expected_headers["status"] = "200";
-
-  test_cases[1].expected_headers["hello"] = "bye";
   test_cases[1].expected_headers["status"] = "200";
-
-  test_cases[2].expected_headers["cookie"] = "val1,val2";
-  test_cases[2].expected_headers["hello"] = "bye";
   test_cases[2].expected_headers["status"] = "200";
 
+  // HTTP/2 eliminates use of the :version header.
   if (spdy_util_.spdy_version() < HTTP2) {
-    // HTTP/2 eliminates use of the :version header.
     test_cases[0].expected_headers["version"] = "HTTP/1.1";
     test_cases[1].expected_headers["version"] = "HTTP/1.1";
     test_cases[2].expected_headers["version"] = "HTTP/1.1";
   }
 
+  test_cases[0].expected_headers["hello"] = "bye";
+  test_cases[1].expected_headers["hello"] = "bye";
+  test_cases[2].expected_headers["hello"] = "bye";
+
+  test_cases[0].expected_headers["cookie"] = StringPiece("val1\0val2", 9);
+  test_cases[2].expected_headers["cookie"] = "val1,val2";
+
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
     scoped_ptr<SpdyFrame> req(
         spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
     MockWrite writes[] = {CreateMockWrite(*req, 0)};
 
     scoped_ptr<SpdyFrame> resp(
         spdy_util_.ConstructSpdyGetSynReply(test_cases[i].extra_headers,
                                  test_cases[i].num_headers,
                                  1));
     scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
@@ skipping 13 matching lines @@
     EXPECT_EQ(OK, out.rv);
     EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
     EXPECT_EQ("hello!", out.response_data);
 
     scoped_refptr<HttpResponseHeaders> headers = out.response_info.headers;
     EXPECT_TRUE(headers.get() != NULL);
     void* iter = NULL;
     std::string name, value;
     SpdyHeaderBlock header_block;
     while (headers->EnumerateHeaderLines(&iter, &name, &value)) {
-      if (header_block[name].empty()) {
-        header_block[name] = value;
+      SpdyHeaderBlock::StringPieceProxy mutable_header_block_value =
+          header_block[name];
+      if (static_cast<StringPiece>(mutable_header_block_value).empty()) {
+        mutable_header_block_value = value;
       } else {
-        header_block[name] += '\0';
-        header_block[name] += value;
+        std::string joint_value = mutable_header_block_value.as_string();
+        joint_value.append(1, '\0');
+        joint_value.append(value);
+        mutable_header_block_value = joint_value;
       }
     }
     EXPECT_EQ(test_cases[i].expected_headers, header_block);
   }
 }
 
 // Verify that various SynReply headers parse vary fields correctly
 // through the HTTP layer, and the response matches the request.
 TEST_P(SpdyNetworkTransactionTest, SynReplyHeadersVary) {
   // Modify the following data to change/add test cases:
   struct SynReplyTests {
     bool vary_matches;
     int num_headers[2];
     const char* extra_headers[2][16];
   } test_cases[] = {
-    // Test the case of a multi-valued cookie.  When the value is delimited
-    // with NUL characters, it needs to be unfolded into multiple headers.
-    {
-      true,
-      { 1, 4 },
-      { { "cookie",   "val1,val2",
-          NULL
-        },
-        { "vary",     "cookie",
-          spdy_util_.GetStatusKey(), "200",
-          spdy_util_.GetPathKey(),      "/index.php",
-          spdy_util_.GetVersionKey(), "HTTP/1.1",
-          NULL
-        }
-      }
-    }, {    // Multiple vary fields.
-      true,
-      { 2, 5 },
-      { { "friend",   "barney",
-          "enemy",    "snaggletooth",
-          NULL
-        },
-        { "vary",     "friend",
-          "vary",     "enemy",
-          spdy_util_.GetStatusKey(), "200",
-          spdy_util_.GetPathKey(),      "/index.php",
-          spdy_util_.GetVersionKey(), "HTTP/1.1",
-          NULL
-        }
-      }
-    }, {    // Test a '*' vary field.
-      false,
-      { 1, 4 },
-      { { "cookie",   "val1,val2",
-          NULL
-        },
-        { "vary",     "*",
-          spdy_util_.GetStatusKey(), "200",
-          spdy_util_.GetPathKey(),      "/index.php",
-          spdy_util_.GetVersionKey(), "HTTP/1.1",
-          NULL
-        }
-      }
-    }, {    // Multiple comma-separated vary fields.
-      true,
-      { 2, 4 },
-      { { "friend",   "barney",
-          "enemy",    "snaggletooth",
-          NULL
-        },
-        { "vary",     "friend,enemy",
-          spdy_util_.GetStatusKey(), "200",
-          spdy_util_.GetPathKey(),      "/index.php",
-          spdy_util_.GetVersionKey(), "HTTP/1.1",
-          NULL
-        }
-      }
-    }
-  };
+      // Test the case of a multi-valued cookie.  When the value is delimited
+      // with NUL characters, it needs to be unfolded into multiple headers.
+      {true,
+       {1, 4},
+       {{"cookie", "val1,val2", NULL},
+        {spdy_util_.GetStatusKey(), "200", spdy_util_.GetPathKey(),
+         "/index.php", spdy_util_.GetVersionKey(), "HTTP/1.1", "vary", "cookie",
+         NULL}}},
+      {// Multiple vary fields.
+       true,
+       {2, 5},
+       {{"friend", "barney", "enemy", "snaggletooth", NULL},
+        {spdy_util_.GetStatusKey(), "200", spdy_util_.GetPathKey(),
+         "/index.php", spdy_util_.GetVersionKey(), "HTTP/1.1", "vary", "friend",
+         "vary", "enemy", NULL}}},
+      {// Test a '*' vary field.
+       false,
+       {1, 4},
+       {{"cookie", "val1,val2", NULL},
+        {spdy_util_.GetStatusKey(), "200", spdy_util_.GetPathKey(),
+         "/index.php", spdy_util_.GetVersionKey(), "HTTP/1.1", "vary", "*",
+         NULL}}},
+      {// Multiple comma-separated vary fields.
+       true,
+       {2, 4},
+       {{"friend", "barney", "enemy", "snaggletooth", NULL},
+        {spdy_util_.GetStatusKey(), "200", spdy_util_.GetPathKey(),
+         "/index.php", spdy_util_.GetVersionKey(), "HTTP/1.1", "vary",
+         "friend,enemy", NULL}}}};
 
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
     // Construct the request.
     scoped_ptr<SpdyFrame> frame_req(
         spdy_util_.ConstructSpdyGet(test_cases[i].extra_headers[0],
                                     test_cases[i].num_headers[0],
                                     false, 1, LOWEST, true));
 
     MockWrite writes[] = {
         CreateMockWrite(*frame_req, 0),
@@ skipping 57 matching lines @@
     EXPECT_EQ(expected_reply, lines) << i;
   }
 }
 
 // Verify that we don't crash on invalid SynReply responses.
 TEST_P(SpdyNetworkTransactionTest, InvalidSynReply) {
   struct InvalidSynReplyTests {
     int num_headers;
     const char* headers[10];
   } test_cases[] = {
-    // SYN_REPLY missing status header
-    { 4,
-      { "cookie", "val1",
-        "cookie", "val2",
-        spdy_util_.GetPathKey(), "/index.php",
-        spdy_util_.GetVersionKey(), "HTTP/1.1",
-        NULL
+      // SYN_REPLY missing status header
+      {
+          4,
+          {spdy_util_.GetPathKey(), "/index.php", spdy_util_.GetVersionKey(),
+           "HTTP/1.1", "cookie", "val1", "cookie", "val2", NULL},
       },
-    },
-    // SYN_REPLY missing version header
-    { 2,
-      { "status", "200",
-        spdy_util_.GetPathKey(), "/index.php",
-        NULL
+      // SYN_REPLY missing version header
+      {
+          2, {spdy_util_.GetPathKey(), "/index.php", "status", "200", NULL},
       },
-    },
-    // SYN_REPLY with no headers
-    { 0, { NULL }, },
+      // SYN_REPLY with no headers
+      {
+          0, {NULL},
+      },
   };
 
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
     scoped_ptr<SpdyFrame> req(
         spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
     scoped_ptr<SpdyFrame> rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR));
     MockWrite writes[] = {
         CreateMockWrite(*req, 0), CreateMockWrite(*rst, 2),
     };
@@ skipping 1708 matching lines @@
       CreateMockWrite(*stream1_syn, 0),
   };
 
   scoped_ptr<SpdyHeaderBlock> initial_headers(new SpdyHeaderBlock());
   spdy_util_.AddUrlToHeaderBlock(GetDefaultUrlWithPath("/foo.dat"),
                                  initial_headers.get());
   scoped_ptr<SpdyFrame> stream2_syn(
       spdy_util_.ConstructInitialSpdyPushFrame(initial_headers.Pass(), 2, 1));
 
   scoped_ptr<SpdyHeaderBlock> late_headers(new SpdyHeaderBlock());
-  (*late_headers)["hello"] = "bye";
   (*late_headers)[spdy_util_.GetStatusKey()] = "200";
   (*late_headers)[spdy_util_.GetVersionKey()] = "HTTP/1.1";
+  (*late_headers)["hello"] = "bye";
   scoped_ptr<SpdyFrame> stream2_headers(
       spdy_util_.ConstructSpdyControlFrame(late_headers.Pass(),
                                            false,
                                            2,
                                            LOWEST,
                                            HEADERS,
                                            CONTROL_FLAG_NONE,
                                            0));
 
   scoped_ptr<SpdyFrame>
@@ skipping 39 matching lines @@
     CreateMockWrite(*stream1_syn, 0, SYNCHRONOUS),
   };
 
   scoped_ptr<SpdyHeaderBlock> initial_headers(new SpdyHeaderBlock());
   spdy_util_.AddUrlToHeaderBlock(GetDefaultUrlWithPath("/foo.dat"),
                                  initial_headers.get());
   scoped_ptr<SpdyFrame> stream2_syn(
       spdy_util_.ConstructInitialSpdyPushFrame(initial_headers.Pass(), 2, 1));
 
   scoped_ptr<SpdyHeaderBlock> late_headers(new SpdyHeaderBlock());
-  (*late_headers)["hello"] = "bye";
   (*late_headers)[spdy_util_.GetStatusKey()] = "200";
   (*late_headers)[spdy_util_.GetVersionKey()] = "HTTP/1.1";
+  (*late_headers)["hello"] = "bye";
   scoped_ptr<SpdyFrame> stream2_headers(
       spdy_util_.ConstructSpdyControlFrame(late_headers.Pass(),
                                            false,
                                            2,
                                            LOWEST,
                                            HEADERS,
                                            CONTROL_FLAG_NONE,
                                            0));
 
   scoped_ptr<SpdyFrame>
@@ skipping 1531 matching lines @@
 TEST_P(SpdyNetworkTransactionTLSUsageCheckTest, TLSCipherSuiteSucky) {
   scoped_ptr<SSLSocketDataProvider> ssl_provider(
       new SSLSocketDataProvider(ASYNC, OK));
   // Set to TLS_RSA_WITH_NULL_MD5
   SSLConnectionStatusSetCipherSuite(0x1, &ssl_provider->connection_status);
 
   RunTLSUsageCheckTest(ssl_provider.Pass());
 }
 
 }  // namespace net