Integrate the SpdyProxyClientSocket into the HttpStreamRequest...

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_number_conversions.h"
@@ skipping 389 matching lines @@
                                    extra_header_count,
                                    compressed,
                                    stream_id,
                                    request_priority,
                                    spdy::SYN_STREAM,
                                    spdy::CONTROL_FLAG_FIN,
                                    kStandardGetHeaders,
                                    arraysize(kStandardGetHeaders));
 }
 
+// Constructs a standard SPDY SYN_STREAM frame for a CONNECT request.
+spdy::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",
+    "proxy-connection", "keep-alive",
+  };
+  return ConstructSpdyControlFrame(extra_headers,
+                                   extra_header_count,
+                                   /*compressed*/ false,
+                                   stream_id,
+                                   LOWEST,
+                                   spdy::SYN_STREAM,
+                                   spdy::CONTROL_FLAG_NONE,
+                                   kConnectHeaders,
+                                   arraysize(kConnectHeaders));
+}
+
 // Constructs a standard SPDY push SYN packet.
 // |extra_headers| are the extra header-value pairs, which typically
 // will vary the most between calls.
 // Returns a SpdyFrame.
 spdy::SpdyFrame* ConstructSpdyPush(const char* const extra_headers[],
                                    int extra_header_count,
                                    int stream_id,
                                    int associated_stream_id) {
   const char* const kStandardGetHeaders[] = {
     "hello",
@@ skipping 97 matching lines @@
                                    0,
                                    false,
                                    stream_id,
                                    LOWEST,
                                    spdy::SYN_REPLY,
                                    spdy::CONTROL_FLAG_NONE,
                                    kStandardGetHeaders,
                                    arraysize(kStandardGetHeaders));
 }
 
+// Constructs a standard SPDY SYN_REPLY packet with an Internal Server
+// Error status code.
+// Returns a SpdyFrame.
+spdy::SpdyFrame* ConstructSpdySynReplyError(int stream_id) {
+  return ConstructSpdySynReplyError("500 Internal Server Error", 1);
+}
+
+// Constructs a standard SPDY SYN_REPLY packet with the specified status code.
+// Returns a SpdyFrame.
+spdy::SpdyFrame* ConstructSpdySynReplyError(const char* const status,
+                                            int stream_id) {
+  static const char* const kStandardGetHeaders[] = {
+    "hello",
+    "bye",
+    "status",
+    status,
+    "version",
+    "HTTP/1.1"
+  };
+  return ConstructSpdyControlFrame(NULL,
+                                   0,
+                                   false,
+                                   stream_id,
+                                   LOWEST,
+                                   spdy::SYN_REPLY,
+                                   spdy::CONTROL_FLAG_NONE,
+                                   kStandardGetHeaders,
+                                   arraysize(kStandardGetHeaders));
+}
+
 // 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 stream_id) {
   static const char* const kStandardGetHeaders[] = {
     "hello",
     "bye",
@@ skipping 85 matching lines @@
 }
 
 // Constructs a single SPDY data frame with the given content.
 spdy::SpdyFrame* ConstructSpdyBodyFrame(int stream_id, const char* data,
                                         uint32 len, bool fin) {
   spdy::SpdyFramer framer;
   return framer.CreateDataFrame(
       stream_id, data, len, fin ? spdy::DATA_FLAG_FIN : spdy::DATA_FLAG_NONE);
 }
 
+// Wraps |frame| in the payload of a data frame in stream |stream_id|.
+spdy::SpdyFrame* ConstructWrappedSpdyFrame(
+    const scoped_ptr<spdy::SpdyFrame>& frame,
+    int stream_id) {
+  return ConstructSpdyBodyFrame(stream_id, frame->data(),
+                                frame->length() + spdy::SpdyFrame::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 packet_size = 0;
@@ skipping 126 matching lines @@
     spdy::CONTROL_FLAG_FIN,       // Control Flags
     false,                        // Compressed
     spdy::INVALID,                // Status
     NULL,                         // Data
     0,                            // Length
     spdy::DATA_FLAG_NONE          // Data Flags
   };
   return kHeader;
 }
 }  // namespace net