Use HttpRequestHeaders for extra_headers.

net/spdy/spdy_network_transaction_unittest.cc

 // Copyright (c) 2010 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/spdy_network_transaction.h"
 
 #include "base/basictypes.h"
 #include "base/ref_counted.h"
 #include "base/string_util.h"
 #include "net/base/completion_callback.h"
@@ skipping 482 matching lines @@
                                   &buffer_write,
                                   &buffer_left);
     packet_size += AppendToBuffer("\n",
                                   strlen("\n"),
                                   &buffer_write,
                                   &buffer_left);
   }
   return packet_size;
 }
 
-// Construct a single SPDY header entry, for validation.
-// |extra_headers| are the extra header-value pairs.
-// |buffer| is the buffer we're filling in.
-// |index| is the index of the header we want.
-// Returns the number of bytes written into |buffer|.
-int ConstructSpdyHeader(const char* const extra_headers[],
-                        int extra_header_count,
-                        char* buffer,
-                        int buffer_length,
-                        int index) {
-  const char* this_header = NULL;
-  const char* this_value = NULL;
-  if (!buffer || !buffer_length)
-    return 0;
-  *buffer = '\0';
-  // Sanity check: Non-empty header list.
-  DCHECK(NULL != extra_headers) << "NULL extra headers pointer";
-  // Sanity check: Index out of range.
-  DCHECK((index >= 0) && (index < extra_header_count))
-      << "Index " << index
-      << " out of range [0, " << extra_header_count << ")";
-  this_header = extra_headers[index * 2];
-  // Sanity check: Non-empty header.
-  if (!*this_header)
-    return 0;
-  std::string::size_type header_len = strlen(this_header);
-  if (!header_len)
-    return 0;
-  this_value = extra_headers[1 + (index * 2)];
-  // Sanity check: Non-empty value.
-  if (!*this_value)
-    this_value = "";
-  int n = base::snprintf(buffer,
-                         buffer_length,
-                         "%s: %s\r\n",
-                         this_header,
-                         this_value);
-  return n;
-}
-
 // Constructs a standard SPDY GET packet.
 // |extra_headers| are the extra header-value pairs, which typically
 // will vary the most between calls.
 // Returns a SpdFrame.
 spdy::SpdyFrame* ConstructSpdyGet(const char* const extra_headers[],
                                   int extra_header_count) {
   SpdyHeaderInfo SynStartHeader = {
     spdy::SYN_STREAM,             // Kind = Syn
     1,                            // Stream ID
     0,                            // Associated stream ID
@@ skipping 609 matching lines @@
     const SpdyHeaderInfo* syn_reply;
     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.
     {
       &syn_reply_info,
       true,
-      { 2, 4 },
-      { { "cookie",   "val1",
-          "cookie",   "val2",
+      { 1, 4 },
+      { { "cookie",   "val1,val2",
           NULL
         },
         { "vary",     "cookie",
           "status",   "200",
           "url",      "/index.php",
           "version",  "HTTP/1.1",
           NULL
         }
       }
     }, {    // Multiple vary fields.
@@ skipping 38 matching lines @@
           "status",   "200",
           "url",      "/index.php",
           "version",  "HTTP/1.1",
           NULL
         }
       }
     }
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
-    char modified_syn_header[64];
-
     // Construct the request.
     scoped_ptr<spdy::SpdyFrame> frame_req(
       ConstructSpdyGet(test_cases[i].extra_headers[0],
                        test_cases[i].num_headers[0]));
 
     MockWrite writes[] = {
       MockWrite(
           true,
           frame_req->data(),
           frame_req->length() + spdy::SpdyFrame::size()),
@@ skipping 16 matching lines @@
                arraysize(kGetBodyFrame)),
       MockRead(true, 0, 0)  // EOF
     };
 
     HttpRequestInfo request;
     request.method = "GET";
     request.url = GURL("http://www.google.com/");
     request.load_flags = 0;
 
     // Attach the headers to the request.
-    int hdrCount = test_cases[i].num_headers[0];
-    int len = 0;
+    int header_count = test_cases[i].num_headers[0];
 
-    for (int ct = 0; ct < hdrCount; ct++) {
-      len = ConstructSpdyHeader(test_cases[i].extra_headers[0],
-                                test_cases[i].num_headers[0],
-                                modified_syn_header,
-                                64,
-                                ct);
-
-      request.extra_headers.append(modified_syn_header);
+    for (int ct = 0; ct < header_count; ct++) {
+      const char* header_key = test_cases[i].extra_headers[0][ct * 2];
+      const char* header_value = test_cases[i].extra_headers[0][ct * 2 + 1];
+      request.extra_headers.SetHeader(header_key, header_value);
     }
 
     scoped_refptr<DelayedSocketData> data(
         new DelayedSocketData(1, reads, arraysize(reads),
                               writes, arraysize(writes)));
     TransactionHelperResult out = TransactionHelper(request, data.get(), NULL);
     EXPECT_EQ(OK, out.rv) << i;
     EXPECT_EQ("HTTP/1.1 200 OK", out.status_line) << i;
     EXPECT_EQ("hello!", out.response_data) << i;
 
@@ skipping 1160 matching lines @@
     // We shouldn't get here in this test.
     FAIL() << "Unexpected read: " << rv;
   } while (rv > 0);
 
   // Flush the MessageLoop; this will cause the buffered IO task
   // to run for the final time.
   MessageLoop::current()->RunAllPending();
 }
 
 }  // namespace net