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

net/spdy/spdy_test_util_spdy3.h

 // 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.
 
 #ifndef NET_SPDY_SPDY_TEST_UTIL_SPDY3_H_
 #define NET_SPDY_SPDY_TEST_UTIL_SPDY3_H_
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/string_piece.h"
 #include "crypto/ec_private_key.h"
 #include "crypto/ec_signature_creator.h"
 #include "net/base/cert_verifier.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/mock_host_resolver.h"
 #include "net/base/request_priority.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_network_layer.h"
 #include "net/http/http_network_session.h"
@@ skipping 88 matching lines @@
 // Chop a SpdyFrame into an array of MockReads.
 // |frame| is the frame to chop.
 // |num_chunks| is the number of chunks to create.
 MockRead* ChopReadFrame(const SpdyFrame& frame, int 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 AppendHeadersToBlock(const char* const extra_headers[],
+                          int extra_header_count,
+                          SpdyHeaderBlock* headers);
+
+// Constructs a HeaderBlock for the given URL.
+scoped_ptr<SpdyHeaderBlock> ConstructGetHeaderBlock(base::StringPiece url);
+
+// Constructs a HeaderBlock for a POST request for the given URL.
+scoped_ptr<SpdyHeaderBlock> ConstructPostHeaderBlock(base::StringPiece url,
+                                                     int64 content_length);
 
 // Writes |str| of the given |len| to the buffer pointed to by |buffer_handle|.
 // Uses a template so buffer_handle can be a char* or an unsigned char*.
 // Updates the |*buffer_handle| pointer by |len|
 // Returns the number of bytes written into *|buffer_handle|
 template<class T>
 int AppendToBuffer(const char* str,
                    int len,
                    T** buffer_handle,
                    int* buffer_len_remaining) {
@@ skipping 11 matching lines @@
 
 // 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);
 
-// Construct a SPDY packet.
-// |head| is the start of the packet, up to but not including
-// the header value pairs.
+// Construct a SPDY frame.
+SpdyFrame* ConstructSpdyFrame(const SpdyHeaderInfo& header_info,
+                              scoped_ptr<SpdyHeaderBlock> headers);
+
+// Construct a SPDY frame.
 // |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);
+SpdyFrame* ConstructSpdyFrame(const SpdyHeaderInfo& header_info,
+                              const char* const extra_headers[],
+                              int extra_header_count,
+                              const char* const tail[],
+                              int tail_header_count);
 
 // Construct a generic SpdyControlFrame.
 SpdyFrame* ConstructSpdyControlFrame(const char* const extra_headers[],
                                      int extra_header_count,
                                      bool compressed,
                                      int stream_id,
                                      RequestPriority request_priority,
                                      SpdyControlType type,
                                      SpdyControlFlags flags,
                                      const char* const* kHeaders,
@@ skipping 50 matching lines @@
 // |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);
 
-// 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);
 
-// 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);
 
-// 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.  If |direct| is false, the
 // the full url will be used instead of simply the path.
 // Returns a SpdyFrame.
 SpdyFrame* ConstructSpdyGet(const char* const extra_headers[],
                             int extra_header_count,
                             bool compressed,
                             int stream_id,
                             RequestPriority request_priority,
                             bool direct);
 
 // 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);
 
-// 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);
 SpdyFrame* ConstructSpdyPush(const char* const extra_headers[],
                              int extra_header_count,
                              int stream_id,
                              int associated_stream_id,
                              const char* url);
 SpdyFrame* ConstructSpdyPush(const char* const extra_headers[],
                              int extra_header_count,
                              int stream_id,
                              int associated_stream_id,
                              const char* url,
                              const char* status,
                              const char* location);
 SpdyFrame* ConstructSpdyPush(int stream_id,
                              int associated_stream_id,
                              const char* url);
 
 SpdyFrame* ConstructSpdyPushHeaders(int stream_id,
                                     const char* const extra_headers[],
                                     int extra_header_count);
 
-// 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);
 
-// 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);
 
-// 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);
 
-// 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);
 
-// Constructs a standard SPDY POST SYN packet.
+// Constructs a standard SPDY POST SYN frame.
 // |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,
+                             SpdyStreamId stream_id,
+                             int64 content_length,
+                             RequestPriority priority,
                              const char* const extra_headers[],
                              int extra_header_count);
 
-// 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);
 
-// 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);
 
 // Constructs a single SPDY data frame with the contents "hello!"
 SpdyFrame* ConstructSpdyBodyFrame(int stream_id,
                                   bool fin);
 
@@ skipping 107 matching lines @@
   SpdySessionPool* const pool_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdySessionPoolPeer);
 };
 
 }  // namespace test_spdy3
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_TEST_UTIL_SPDY3_H_