Implement MAX_CONCURRENT_STREAMS SETTINGS header

net/spdy/spdy_test_util.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_test_util.h"
 
+#include <string>
+
 #include "base/basictypes.h"
 #include "base/string_util.h"
 
 namespace net {
 
 // Chop a frame into an array of MockWrites.
 // |data| is the frame to chop.
 // |length| is the length of the frame to chop.
 // |num_chunks| is the number of chunks to create.
 MockWrite* ChopWriteFrame(const char* data, int length, int num_chunks) {
@@ skipping 211 matching lines @@
                          this_header,
                          this_value);
   return n;
 }
 
 // Constructs a standard SPDY GET SYN packet, optionally compressed.
 // |extra_headers| are the extra header-value pairs, which typically
 // will vary the most between calls.
 // Returns a SpdyFrame.
 spdy::SpdyFrame* ConstructSpdyGet(const char* const extra_headers[],
-                                  int extra_header_count, bool compressed) {
+                                  int extra_header_count,
+                                  bool compressed,
+                                  int stream_id,
+                                  RequestPriority request_priority) {
   const SpdyHeaderInfo kSynStartHeader = {
     spdy::SYN_STREAM,             // Kind = Syn
-    1,                            // Stream ID
+    stream_id,                    // Stream ID
     0,                            // Associated stream ID
-    SPDY_PRIORITY_LOWEST,         // Priority
+    request_priority,             // Priority
     spdy::CONTROL_FLAG_FIN,       // Control Flags
     compressed,                   // Compressed
     spdy::INVALID,                // Status
     NULL,                         // Data
     0,                            // Length
     spdy::DATA_FLAG_NONE          // Data Flags
   };
   static const char* const kStandardGetHeaders[] = {
     "method",
     "GET",
     "url",
     "http://www.google.com/",
     "version",
     "HTTP/1.1"
   };
   return ConstructSpdyPacket(
       kSynStartHeader,
       extra_headers,
       extra_header_count,
       kStandardGetHeaders,
       arraysize(kStandardGetHeaders) / 2);
 }
 
-// Constructs a standard SPDY GET SYN packet, not compressed.
-// |extra_headers| are the extra header-value pairs, which typically
-// will vary the most between calls.
-// Returns a SpdyFrame.
-spdy::SpdyFrame* ConstructSpdyGet(const char* const extra_headers[],
-                                  int extra_header_count) {
-  return ConstructSpdyGet(extra_headers, extra_header_count, false);
-}
-
 // Constructs a standard SPDY SYN_REPLY packet to match the SPDY GET.
 // |extra_headers| are the extra header-value pairs, which typically
 // will vary the most between calls.
 // Returns a SpdyFrame.
 spdy::SpdyFrame* ConstructSpdyGetSynReply(const char* const extra_headers[],
-                                          int extra_header_count) {
+                                          int extra_header_count,
+                                          int stream_id) {
   const SpdyHeaderInfo kSynStartHeader = {
     spdy::SYN_REPLY,              // Kind = SynReply
-    1,                            // Stream ID
+    stream_id,                    // Stream ID
     0,                            // Associated stream ID
     SPDY_PRIORITY_LOWEST,         // Priority
     spdy::CONTROL_FLAG_NONE,      // Control Flags
     false,                        // Compressed
     spdy::INVALID,                // Status
     NULL,                         // Data
     0,                            // Length
     spdy::DATA_FLAG_NONE          // Data Flags
   };
   static const char* const kStandardGetHeaders[] = {
@@ skipping 78 matching lines @@
   };
   return ConstructSpdyPacket(
       kSynStartHeader,
       extra_headers,
       extra_header_count,
       kStandardGetHeaders,
       arraysize(kStandardGetHeaders) / 2);
 }
 
 // Constructs a single SPDY data frame with the contents "hello!"
-spdy::SpdyFrame* ConstructSpdyBodyFrame() {
+spdy::SpdyFrame* ConstructSpdyBodyFrame(int stream_id, bool fin) {
   spdy::SpdyFramer framer;
-  return framer.CreateDataFrame(1, "hello!", 6, spdy::DATA_FLAG_FIN);
+  return
+      framer.CreateDataFrame(stream_id, "hello!", 6,
+                             fin ? spdy::DATA_FLAG_FIN : spdy::DATA_FLAG_NONE);
 }
 
 // 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,
@@ skipping 103 matching lines @@
   char* ptr = buff;
   for (int i = 0; i < num_frames; ++i) {
     int len = frames[i]->length() + spdy::SpdyFrame::size();
     memcpy(ptr, frames[i]->data(), len);
     ptr += len;
   }
   return total_len;
 }
 
 }  // namespace net