[SPDY] Refactor tests in preparation for a fix for a session flow control bug

net/spdy/spdy_test_util_spdy2.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 "net/spdy/spdy_test_util_spdy2.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
@@ skipping 72 matching lines @@
 // |num_chunks| is the number of chunks to create.
 MockRead* ChopReadFrame(const SpdyFrame& frame, int num_chunks) {
   return ChopReadFrame(frame.data(), frame.size(), num_chunks);
 }
 
 // Adds headers and values to a map.
 // |extra_headers| is an array of { name, value } pairs, arranged as strings
 // where the even entries are the header names, and the odd entries are the
 // header values.
 // |headers| gets filled in from |extra_headers|.
-void AppendHeadersToSpdyFrame(const char* const extra_headers[],
-                              int extra_header_count,
-                              SpdyHeaderBlock* headers) {
+void AppendToHeaderBlock(const char* const extra_headers[],
+                         int extra_header_count,
+                         SpdyHeaderBlock* headers) {
   std::string this_header;
   std::string this_value;
 
   if (!extra_header_count)
     return;
 
   // Sanity check: Non-NULL header list.
   DCHECK(NULL != extra_headers) << "NULL header value pair list";
   // Sanity check: Non-NULL header map.
   DCHECK(NULL != headers) << "NULL header map";
@@ skipping 19 matching lines @@
       // Append the new value.
       new_value += this_value;
     } else {
       // Not a duplicate, just write the value.
       new_value = this_value;
     }
     (*headers)[this_header] = new_value;
   }
 }
 
+scoped_ptr<SpdyHeaderBlock> ConstructGetHeaderBlock(base::StringPiece url) {
+  std::string scheme, host, path;
+  ParseUrl(url.data(), &scheme, &host, &path);
+  const char* const headers[] = {
+    "method",  "GET",
+    "url",     path.c_str(),
+    "host",    host.c_str(),
+    "scheme",  scheme.c_str(),
+    "version", "HTTP/1.1"
+  };
+  scoped_ptr<SpdyHeaderBlock> header_block(new SpdyHeaderBlock());
+  AppendToHeaderBlock(headers, arraysize(headers) / 2, header_block.get());
+  return header_block.Pass();
+}
+
+scoped_ptr<SpdyHeaderBlock> ConstructPostHeaderBlock(base::StringPiece url,
+                                                     int64 content_length) {
+  std::string scheme, host, path;
+  ParseUrl(url.data(), &scheme, &host, &path);
+  std::string length_str = base::Int64ToString(content_length);
+  const char* const headers[] = {
+    "method",  "POST",
+    "url",     path.c_str(),
+    "host",    host.c_str(),
+    "scheme",  scheme.c_str(),
+    "version", "HTTP/1.1",
+    "content-length", length_str.c_str()
+  };
+  scoped_ptr<SpdyHeaderBlock> header_block(new SpdyHeaderBlock());
+  AppendToHeaderBlock(headers, arraysize(headers) / 2, header_block.get());
+  return header_block.Pass();
+}
+
 // Writes |val| to a location of size |len|, in big-endian format.
 // in the buffer pointed to by |buffer_handle|.
 // Updates the |*buffer_handle| pointer by |len|
 // Returns the number of bytes written
 int AppendToBuffer(int val,
                    int len,
                    unsigned char** buffer_handle,
                    int* buffer_len_remaining) {
   if (len <= 0)
     return 0;
   DCHECK((size_t) len <= sizeof(len)) << "Data length too long for data type";
   DCHECK(NULL != buffer_handle) << "NULL buffer handle";
   DCHECK(NULL != *buffer_handle) << "NULL pointer";
   DCHECK(NULL != buffer_len_remaining)
       << "NULL buffer remainder length pointer";
   DCHECK_GE(*buffer_len_remaining, len) << "Insufficient buffer size";
   for (int i = 0; i < len; i++) {
     int shift = (8 * (len - (i + 1)));
     unsigned char val_chunk = (val >> shift) & 0x0FF;
     *(*buffer_handle)++ = val_chunk;
     *buffer_len_remaining += 1;
   }
   return len;
 }
 
-// Construct a SPDY packet.
-// |head| is the start of the packet, up to but not including
-// the header value pairs.
-// |extra_headers| are the extra header-value pairs, which typically
-// will vary the most between calls.
-// |tail| is any (relatively constant) header-value pairs to add.
-// |buffer| is the buffer we're filling in.
-// Returns a SpdyFrame.
-SpdyFrame* ConstructSpdyPacket(const SpdyHeaderInfo& header_info,
-                               const char* const extra_headers[],
-                               int extra_header_count,
-                               const char* const tail[],
-                               int tail_header_count) {
-  BufferedSpdyFramer framer(2, header_info.compressed);
-  SpdyHeaderBlock headers;
-  // Copy in the extra headers to our map.
-  AppendHeadersToSpdyFrame(extra_headers, extra_header_count, &headers);
-  // Copy in the tail headers to our map.
-  if (tail && tail_header_count)
-    AppendHeadersToSpdyFrame(tail, tail_header_count, &headers);
+SpdyFrame* ConstructSpdyFrame(const SpdyHeaderInfo& header_info,
+                              scoped_ptr<SpdyHeaderBlock> headers) {
+  BufferedSpdyFramer framer(kSpdyVersion2, header_info.compressed);
   SpdyFrame* frame = NULL;
   switch (header_info.kind) {
     case SYN_STREAM:
       frame = framer.CreateSynStream(header_info.id, header_info.assoc_id,
                                      header_info.priority, 0,
                                      header_info.control_flags,
-                                     header_info.compressed, &headers);
+                                     header_info.compressed, headers.get());
       break;
     case SYN_REPLY:
       frame = framer.CreateSynReply(header_info.id, header_info.control_flags,
-                                    header_info.compressed, &headers);
+                                    header_info.compressed, headers.get());
       break;
     case RST_STREAM:
       frame = framer.CreateRstStream(header_info.id, header_info.status);
       break;
     case HEADERS:
       frame = framer.CreateHeaders(header_info.id, header_info.control_flags,
-                                   header_info.compressed, &headers);
+                                   header_info.compressed, headers.get());
       break;
     default:
       frame = framer.CreateDataFrame(header_info.id, header_info.data,
                                      header_info.data_length,
                                      header_info.data_flags);
       break;
   }
   return frame;
 }
 
+SpdyFrame* ConstructSpdyFrame(const SpdyHeaderInfo& header_info,
+                              const char* const extra_headers[],
+                              int extra_header_count,
+                              const char* const tail[],
+                              int tail_header_count) {
+  scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock());
+  AppendToHeaderBlock(extra_headers, extra_header_count, headers.get());
+  if (tail && tail_header_count)
+    AppendToHeaderBlock(tail, tail_header_count, headers.get());
+  return ConstructSpdyFrame(header_info, headers.Pass());
+}
+
 // Construct an expected SPDY SETTINGS frame.
 // |settings| are the settings to set.
 // Returns the constructed frame.  The caller takes ownership of the frame.
 SpdyFrame* ConstructSpdySettings(const SettingsMap& settings) {
   BufferedSpdyFramer framer(2, false);
   return framer.CreateSettings(settings);
 }
 
 // Construct an expected SPDY CREDENTIAL frame.
 // |credential| is the credential to sen.
@@ skipping 111 matching lines @@
     associated_stream_id,         // Associated stream ID
     ConvertRequestPriorityToSpdyPriority(request_priority, 2),
                                   // Priority
     flags,                        // Control Flags
     compressed,                   // Compressed
     RST_STREAM_INVALID,           // Status
     NULL,                         // Data
     0,                            // Length
     DATA_FLAG_NONE                // Data Flags
   };
-  return ConstructSpdyPacket(kSynStartHeader,
-                             extra_headers,
-                             extra_header_count,
-                             kHeaders,
-                             kHeadersSize / 2);
+  return ConstructSpdyFrame(kSynStartHeader,
+                            extra_headers,
+                            extra_header_count,
+                            kHeaders,
+                            kHeadersSize / 2);
 }
 
-// Constructs a standard SPDY GET SYN packet, optionally compressed
+// Constructs a standard SPDY GET SYN frame, optionally compressed
 // for the url |url|.
 // |extra_headers| are the extra header-value pairs, which typically
 // will vary the most between calls.
 // Returns a SpdyFrame.
 SpdyFrame* ConstructSpdyGet(const char* const url,
                             bool compressed,
                             SpdyStreamId stream_id,
                             RequestPriority request_priority) {
   const SpdyHeaderInfo kSynStartHeader = {
     SYN_STREAM,             // Kind = Syn
     stream_id,              // Stream ID
     0,                      // Associated stream ID
     ConvertRequestPriorityToSpdyPriority(request_priority, 2),
                             // Priority
     CONTROL_FLAG_FIN,       // Control Flags
     compressed,             // Compressed
     RST_STREAM_INVALID,     // Status
     NULL,                   // Data
     0,                      // Length
     DATA_FLAG_NONE          // Data Flags
   };
-
-  std::string scheme, host, path;
-  ParseUrl(url, &scheme, &host, &path);
-  const char* const headers[] = {
-    "method",  "GET",
-    "url",     path.c_str(),
-    "host",    host.c_str(),
-    "scheme",  scheme.c_str(),
-    "version", "HTTP/1.1"
-  };
-  return ConstructSpdyPacket(
-      kSynStartHeader,
-      NULL,
-      0,
-      headers,
-      arraysize(headers) / 2);
+  return ConstructSpdyFrame(kSynStartHeader, ConstructGetHeaderBlock(url));
 }
 
-// Constructs a standard SPDY GET SYN packet, optionally compressed.
+// Constructs a standard SPDY GET SYN frame, optionally compressed.
 // |extra_headers| are the extra header-value pairs, which typically
 // will vary the most between calls.
 // Returns a SpdyFrame.
 SpdyFrame* ConstructSpdyGet(const char* const extra_headers[],
                             int extra_header_count,
                             bool compressed,
                             int stream_id,
                             RequestPriority request_priority) {
   return ConstructSpdyGet(extra_headers, extra_header_count, compressed,
                           stream_id, request_priority, true);
 }
 
-// Constructs a standard SPDY GET SYN packet, optionally compressed.
+// Constructs a standard SPDY GET SYN frame, optionally compressed.
 // |extra_headers| are the extra header-value pairs, which typically
 // will vary the most between calls.
 // Returns a SpdyFrame.
 SpdyFrame* ConstructSpdyGet(const char* const extra_headers[],
                             int extra_header_count,
                             bool compressed,
                             int stream_id,
                             RequestPriority request_priority,
                             bool direct) {
   const char* const kStandardGetHeaders[] = {
@@ skipping 28 matching lines @@
                                    extra_header_count,
                                    /*compressed*/ false,
                                    stream_id,
                                    LOWEST,
                                    SYN_STREAM,
                                    CONTROL_FLAG_NONE,
                                    kConnectHeaders,
                                    arraysize(kConnectHeaders));
 }
 
-// Constructs a standard SPDY push SYN packet.
+// Constructs a standard SPDY push SYN frame.
 // |extra_headers| are the extra header-value pairs, which typically
 // will vary the most between calls.
 // Returns a SpdyFrame.
 SpdyFrame* ConstructSpdyPush(const char* const extra_headers[],
                              int extra_header_count,
                              int stream_id,
                              int associated_stream_id) {
   const char* const kStandardGetHeaders[] = {
     "hello", "bye",
     "status", "200",
@@ skipping 89 matching lines @@
                                    extra_header_count,
                                    false,
                                    stream_id,
                                    LOWEST,
                                    HEADERS,
                                    CONTROL_FLAG_NONE,
                                    kStandardGetHeaders,
                                    arraysize(kStandardGetHeaders));
 }
 
-// Constructs a standard SPDY SYN_REPLY packet with the specified status code.
+// Constructs a standard SPDY SYN_REPLY frame with the specified status code.
 // Returns a SpdyFrame.
 SpdyFrame* ConstructSpdySynReplyError(const char* const status,
                                       const char* const* const extra_headers,
                                       int extra_header_count,
                                       int stream_id) {
   const char* const kStandardGetHeaders[] = {
     "hello", "bye",
     "status", status,
     "version", "HTTP/1.1"
   };
   return ConstructSpdyControlFrame(extra_headers,
                                    extra_header_count,
                                    false,
                                    stream_id,
                                    LOWEST,
                                    SYN_REPLY,
                                    CONTROL_FLAG_NONE,
                                    kStandardGetHeaders,
                                    arraysize(kStandardGetHeaders));
 }
 
-// Constructs a standard SPDY SYN_REPLY packet to match the SPDY GET.
+// Constructs a standard SPDY SYN_REPLY frame to match the SPDY GET.
 // |extra_headers| are the extra header-value pairs, which typically
 // will vary the most between calls.
 // Returns a SpdyFrame.
 SpdyFrame* ConstructSpdyGetSynReplyRedirect(int stream_id) {
   static const char* const kExtraHeaders[] = {
     "location", "http://www.foo.com/index.php",
   };
   return ConstructSpdySynReplyError("301 Moved Permanently", kExtraHeaders,
                                     arraysize(kExtraHeaders)/2, stream_id);
 }
 
-// Constructs a standard SPDY SYN_REPLY packet with an Internal Server
+// Constructs a standard SPDY SYN_REPLY frame with an Internal Server
 // Error status code.
 // Returns a SpdyFrame.
 SpdyFrame* ConstructSpdySynReplyError(int stream_id) {
   return ConstructSpdySynReplyError("500 Internal Server Error", NULL, 0, 1);
 }
 
-// Constructs a standard SPDY SYN_REPLY packet to match the SPDY GET.
+// Constructs a standard SPDY SYN_REPLY frame to match the SPDY GET.
 // |extra_headers| are the extra header-value pairs, which typically
 // will vary the most between calls.
 // Returns a SpdyFrame.
 SpdyFrame* ConstructSpdyGetSynReply(const char* const extra_headers[],
                                     int extra_header_count,
                                     int stream_id) {
   static const char* const kStandardGetHeaders[] = {
     "hello", "bye",
     "status", "200",
     "version", "HTTP/1.1"
   };
   return ConstructSpdyControlFrame(extra_headers,
                                    extra_header_count,
                                    false,
                                    stream_id,
                                    LOWEST,
                                    SYN_REPLY,
                                    CONTROL_FLAG_NONE,
                                    kStandardGetHeaders,
                                    arraysize(kStandardGetHeaders));
 }
 
-// Constructs a standard SPDY POST SYN packet.
+// Constructs a standard SPDY POST SYN frame.
 // |content_length| is the size of post data.
 // |extra_headers| are the extra header-value pairs, which typically
 // will vary the most between calls.
 // Returns a SpdyFrame.
-SpdyFrame* ConstructSpdyPost(int64 content_length,
+SpdyFrame* ConstructSpdyPost(const char* url,
+                             int64 content_length,
                              const char* const extra_headers[],
                              int extra_header_count) {
-  std::string length_str = base::Int64ToString(content_length);
-  const char* post_headers[] = {
-    "method", "POST",
-    "url", "/",
-    "host", "www.google.com",
-    "scheme", "http",
-    "version", "HTTP/1.1",
-    "content-length", length_str.c_str()
+  const SpdyHeaderInfo kSynStartHeader = {
+    SYN_STREAM,             // Kind = Syn
+    1,                      // Stream ID
+    0,                      // Associated stream ID
+    ConvertRequestPriorityToSpdyPriority(LOWEST, 2),
+                            // Priority
+    CONTROL_FLAG_NONE,      // Control Flags
+    false,                  // Compressed
+    RST_STREAM_INVALID,     // Status
+    NULL,                   // Data
+    0,                      // Length
+    DATA_FLAG_NONE          // Data Flags
   };
-  return ConstructSpdyControlFrame(extra_headers,
-                                   extra_header_count,
-                                   false,
-                                   1,
-                                   LOWEST,
-                                   SYN_STREAM,
-                                   CONTROL_FLAG_NONE,
-                                   post_headers,
-                                   arraysize(post_headers));
+  return ConstructSpdyFrame(
+      kSynStartHeader, ConstructPostHeaderBlock(url, content_length));
 }
 
-// Constructs a chunked transfer SPDY POST SYN packet.
+// Constructs a chunked transfer SPDY POST SYN frame.
 // |extra_headers| are the extra header-value pairs, which typically
 // will vary the most between calls.
 // Returns a SpdyFrame.
 SpdyFrame* ConstructChunkedSpdyPost(const char* const extra_headers[],
                                     int extra_header_count) {
   const char* post_headers[] = {
     "method", "POST",
     "url", "/",
     "host", "www.google.com",
     "scheme", "http",
     "version", "HTTP/1.1"
   };
   return ConstructSpdyControlFrame(extra_headers,
                                    extra_header_count,
                                    false,
                                    1,
                                    LOWEST,
                                    SYN_STREAM,
                                    CONTROL_FLAG_NONE,
                                    post_headers,
                                    arraysize(post_headers));
 }
 
-// Constructs a standard SPDY SYN_REPLY packet to match the SPDY POST.
+// Constructs a standard SPDY SYN_REPLY frame to match the SPDY POST.
 // |extra_headers| are the extra header-value pairs, which typically
 // will vary the most between calls.
 // Returns a SpdyFrame.
 SpdyFrame* ConstructSpdyPostSynReply(const char* const extra_headers[],
                                      int extra_header_count) {
   static const char* const kStandardGetHeaders[] = {
     "hello", "bye",
     "status", "200",
     "url", "/index.php",
     "version", "HTTP/1.1"
@@ skipping 34 matching lines @@
 
 // Construct an expected SPDY reply string.
 // |extra_headers| are the extra header-value pairs, which typically
 // will vary the most between calls.
 // |buffer| is the buffer we're filling in.
 // Returns the number of bytes written into |buffer|.
 int ConstructSpdyReplyString(const char* const extra_headers[],
                              int extra_header_count,
                              char* buffer,
                              int buffer_length) {
-  int packet_size = 0;
+  int frame_size = 0;
   char* buffer_write = buffer;
   int buffer_left = buffer_length;
   SpdyHeaderBlock headers;
   if (!buffer || !buffer_length)
     return 0;
   // Copy in the extra headers.
-  AppendHeadersToSpdyFrame(extra_headers, extra_header_count, &headers);
+  AppendToHeaderBlock(extra_headers, extra_header_count, &headers);
   // The iterator gets us the list of header/value pairs in sorted order.
   SpdyHeaderBlock::iterator next = headers.begin();
   SpdyHeaderBlock::iterator last = headers.end();
   for ( ; next != last; ++next) {
     // Write the header.
     int value_len, current_len, offset;
     const char* header_string = next->first.c_str();
-    packet_size += AppendToBuffer(header_string,
-                                  next->first.length(),
-                                  &buffer_write,
-                                  &buffer_left);
-    packet_size += AppendToBuffer(": ",
-                                  strlen(": "),
-                                  &buffer_write,
-                                  &buffer_left);
+    frame_size += AppendToBuffer(header_string,
+                                 next->first.length(),
+                                 &buffer_write,
+                                 &buffer_left);
+    frame_size += AppendToBuffer(": ",
+                                 strlen(": "),
+                                 &buffer_write,
+                                 &buffer_left);
     // Write the value(s).
     const char* value_string = next->second.c_str();
     // Check if it's split among two or more values.
     value_len = next->second.length();
     current_len = strlen(value_string);
     offset = 0;
     // Handle the first N-1 values.
     while (current_len < value_len) {
       // Finish this line -- write the current value.
-      packet_size += AppendToBuffer(value_string + offset,
-                                    current_len - offset,
-                                    &buffer_write,
-                                    &buffer_left);
-      packet_size += AppendToBuffer("\n",
-                                    strlen("\n"),
-                                    &buffer_write,
-                                    &buffer_left);
+      frame_size += AppendToBuffer(value_string + offset,
+                                   current_len - offset,
+                                   &buffer_write,
+                                   &buffer_left);
+      frame_size += AppendToBuffer("\n",
+                                   strlen("\n"),
+                                   &buffer_write,
+                                   &buffer_left);
       // Advance to next value.
       offset = current_len + 1;
       current_len += 1 + strlen(value_string + offset);
       // Start another line -- add the header again.
-      packet_size += AppendToBuffer(header_string,
-                                    next->first.length(),
-                                    &buffer_write,
-                                    &buffer_left);
-      packet_size += AppendToBuffer(": ",
-                                    strlen(": "),
-                                    &buffer_write,
-                                    &buffer_left);
+      frame_size += AppendToBuffer(header_string,
+                                   next->first.length(),
+                                   &buffer_write,
+                                   &buffer_left);
+      frame_size += AppendToBuffer(": ",
+                                   strlen(": "),
+                                   &buffer_write,
+                                   &buffer_left);
     }
     EXPECT_EQ(value_len, current_len);
     // Copy the last (or only) value.
-    packet_size += AppendToBuffer(value_string + offset,
-                                  value_len - offset,
-                                  &buffer_write,
-                                  &buffer_left);
-    packet_size += AppendToBuffer("\n",
-                                  strlen("\n"),
-                                  &buffer_write,
-                                  &buffer_left);
+    frame_size += AppendToBuffer(value_string + offset,
+                                 value_len - offset,
+                                 &buffer_write,
+                                 &buffer_left);
+    frame_size += AppendToBuffer("\n",
+                                 strlen("\n"),
+                                 &buffer_write,
+                                 &buffer_left);
   }
-  return packet_size;
+  return frame_size;
 }
 
 // Create a MockWrite from the given SpdyFrame.
 MockWrite CreateMockWrite(const SpdyFrame& req) {
   return MockWrite(ASYNC, req.data(), req.size());
 }
 
 // Create a MockWrite from the given SpdyFrame and sequence number.
 MockWrite CreateMockWrite(const SpdyFrame& req, int seq) {
   return CreateMockWrite(req, seq, ASYNC);
@@ skipping 169 matching lines @@
     RST_STREAM_INVALID,           // Status
     NULL,                         // Data
     0,                            // Length
     DATA_FLAG_NONE          // Data Flags
   };
   return kHeader;
 }
 
 }  // namespace test_spdy2
 }  // namespace net