Correctly handle SPDY GOAWAY frames.

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 101 matching lines @@
                               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.
-// Returns the constructed frame.  The caller takes ownership of the frame.
 SpdyFrame* ConstructSpdyCredential(
     const SpdyCredential& credential) {
   BufferedSpdyFramer framer(2, false);
   return framer.CreateCredentialFrame(credential);
 }
 
-// Construct a SPDY PING frame.
-// Returns the constructed frame.  The caller takes ownership of the frame.
 SpdyFrame* ConstructSpdyPing(uint32 ping_id) {
   BufferedSpdyFramer framer(2, false);
   return framer.CreatePingFrame(ping_id);
 }
 
-// Construct a SPDY GOAWAY frame.
-// Returns the constructed frame.  The caller takes ownership of the frame.
 SpdyFrame* ConstructSpdyGoAway() {
-  BufferedSpdyFramer framer(2, false);
-  return framer.CreateGoAway(0, GOAWAY_OK);
+  return ConstructSpdyGoAway(0);
 }
 
-// Construct a SPDY WINDOW_UPDATE frame.
-// Returns the constructed frame.  The caller takes ownership of the frame.
+SpdyFrame* ConstructSpdyGoAway(SpdyStreamId last_good_stream_id) {
+  BufferedSpdyFramer framer(2, false);
+  return framer.CreateGoAway(last_good_stream_id, GOAWAY_OK);
+}
+
 SpdyFrame* ConstructSpdyWindowUpdate(
     const SpdyStreamId stream_id, uint32 delta_window_size) {
   BufferedSpdyFramer framer(2, false);
   return framer.CreateWindowUpdate(stream_id, delta_window_size);
 }
 
-// Construct a SPDY RST_STREAM frame.
-// Returns the constructed frame.  The caller takes ownership of the frame.
 SpdyFrame* ConstructSpdyRstStream(SpdyStreamId stream_id,
                                   SpdyRstStreamStatus status) {
   BufferedSpdyFramer framer(2, false);
   return framer.CreateRstStream(stream_id, status);
 }
 
-// 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';
@@ skipping 70 matching lines @@
     0,                            // Length
     DATA_FLAG_NONE                // Data Flags
   };
   return ConstructSpdyFrame(kSynStartHeader,
                             extra_headers,
                             extra_header_count,
                             kHeaders,
                             kHeadersSize / 2);
 }
 
-// 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
   };
   return ConstructSpdyFrame(kSynStartHeader, ConstructGetHeaderBlock(url));
 }
 
-// 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 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[] = {
     "method", "GET",
     "url", (direct ? "/" : "http://www.google.com/"),
     "host", "www.google.com",
     "scheme", "http",
     "version", "HTTP/1.1"
   };
   return ConstructSpdyControlFrame(extra_headers,
                                    extra_header_count,
                                    compressed,
                                    stream_id,
                                    request_priority,
                                    SYN_STREAM,
                                    CONTROL_FLAG_FIN,
                                    kStandardGetHeaders,
                                    arraysize(kStandardGetHeaders));
 }
 
-// Constructs a standard SPDY SYN_STREAM frame for a CONNECT request.
 SpdyFrame* ConstructSpdyConnect(const char* const extra_headers[],
                                 int extra_header_count,
                                 int stream_id) {
   const char* const kConnectHeaders[] = {
     "method", "CONNECT",
     "url", "www.google.com:443",
     "host", "www.google.com",
     "version", "HTTP/1.1",
   };
   return ConstructSpdyControlFrame(extra_headers,
                                    extra_header_count,
                                    /*compressed*/ false,
                                    stream_id,
                                    LOWEST,
                                    SYN_STREAM,
                                    CONTROL_FLAG_NONE,
                                    kConnectHeaders,
                                    arraysize(kConnectHeaders));
 }
 
-// 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",
     "version", "HTTP/1.1"
   };
   return ConstructSpdyControlFrame(extra_headers,
@@ skipping 86 matching lines @@
                                    extra_header_count,
                                    false,
                                    stream_id,
                                    LOWEST,
                                    HEADERS,
                                    CONTROL_FLAG_NONE,
                                    kStandardGetHeaders,
                                    arraysize(kStandardGetHeaders));
 }
 
-// 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 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 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 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 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(const char* url,
                              int64 content_length,
                              const char* const extra_headers[],
                              int extra_header_count) {
   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 ConstructSpdyFrame(
       kSynStartHeader, ConstructPostHeaderBlock(url, content_length));
 }
 
-// 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 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"
   };
   return ConstructSpdyControlFrame(extra_headers,
                                    extra_header_count,
                                    false,
                                    1,
                                    LOWEST,
                                    SYN_REPLY,
                                    CONTROL_FLAG_NONE,
                                    kStandardGetHeaders,
                                    arraysize(kStandardGetHeaders));
 }
 
-// Constructs a single SPDY data frame with the default contents.
 SpdyFrame* ConstructSpdyBodyFrame(int stream_id, bool fin) {
   BufferedSpdyFramer framer(2, false);
   return framer.CreateDataFrame(
       stream_id, kUploadData, kUploadDataSize,
       fin ? DATA_FLAG_FIN : DATA_FLAG_NONE);
 }
 
-// Constructs a single SPDY data frame with the given content.
 SpdyFrame* ConstructSpdyBodyFrame(int stream_id, const char* data,
                                   uint32 len, bool fin) {
   BufferedSpdyFramer framer(2, false);
   return framer.CreateDataFrame(
       stream_id, data, len, fin ? DATA_FLAG_FIN : DATA_FLAG_NONE);
 }
 
-// Wraps |frame| in the payload of a data frame in stream |stream_id|.
 SpdyFrame* ConstructWrappedSpdyFrame(const scoped_ptr<SpdyFrame>& frame,
                                      int stream_id) {
   return ConstructSpdyBodyFrame(stream_id, frame->data(),
                                 frame->size(), false);
 }
 
-// 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 frame_size = 0;
   char* buffer_write = buffer;
   int buffer_left = buffer_length;
   SpdyHeaderBlock headers;
   if (!buffer || !buffer_length)
     return 0;
@@ skipping 190 matching lines @@
     RST_STREAM_INVALID,           // Status
     NULL,                         // Data
     0,                            // Length
     DATA_FLAG_NONE          // Data Flags
   };
   return kHeader;
 }
 
 }  // namespace test_spdy2
 }  // namespace net