[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/base/ssl_config_service_defaults.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_cache.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> ConstructHeaderBlock(base::StringPiece url);
 
 // 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 12 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.
+SpdyFrame* ConstructSpdyPacket(const SpdyHeaderInfo& header_info,
+                               scoped_ptr<SpdyHeaderBlock> headers);
+
+// Construct a SPDY packet.
 // |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);
 
 // Construct a generic SpdyControlFrame.
 SpdyFrame* ConstructSpdyControlFrame(const char* const extra_headers[],
                                      int extra_header_count,
@@ skipping 290 matching lines @@
   SpdySessionPool* const pool_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdySessionPoolPeer);
 };
 
 }  // namespace test_spdy3
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_TEST_UTIL_SPDY3_H_