Properly handle spdy3 responses.

net/spdy/spdy_test_util_spdy3.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_spdy3.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
@@ skipping 453 matching lines @@
 }
 
 // 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.
 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"
+  const char* const kStandardPushHeaders[] = {
+    "hello", "bye",
+    /*
+    ":path", "/somepath",
+    ":host", "www.google.com",
+    ":scheme", "http",
+    */
+    ":status",  "200",
+    ":version", "HTTP/1.1"
   };
   return ConstructSpdyControlFrame(extra_headers,
                                    extra_header_count,
                                    false,
                                    stream_id,
                                    LOWEST,
                                    SYN_STREAM,
                                    CONTROL_FLAG_NONE,
-                                   kStandardGetHeaders,
-                                   arraysize(kStandardGetHeaders),
+                                   kStandardPushHeaders,
+                                   arraysize(kStandardPushHeaders),
                                    associated_stream_id);
 }
 
 SpdyFrame* ConstructSpdyPush(const char* const extra_headers[],
                                    int extra_header_count,
                                    int stream_id,
                                    int associated_stream_id,
                                    const char* url) {
-  const char* const kStandardGetHeaders[] = {
+  GURL gurl(url);
+
+  std::string str_path = gurl.PathForRequest();
+  std::string str_scheme = gurl.scheme();
+  std::string str_host = gurl.host();
+  if (gurl.has_port()) {
+    str_host += ":";
+    str_host += gurl.port();
+  }
+  scoped_array<char> req(new char[str_path.size() + 1]);
+  scoped_array<char> scheme(new char[str_scheme.size() + 1]);
+  scoped_array<char> host(new char[str_host.size() + 1]);
+  memcpy(req.get(), str_path.c_str(), str_path.size());
+  memcpy(scheme.get(), str_scheme.c_str(), str_scheme.size());
+  memcpy(host.get(), str_host.c_str(), str_host.size());
+  req.get()[str_path.size()] = '\0';
+  scheme.get()[str_scheme.size()] = '\0';
+  host.get()[str_host.size()] = '\0';
+
+  const char* const headers[] = {
     "hello",
     "bye",
-    "status",
+    ":status",
     "200 OK",
-    "url",
-    url,
-    "version",
-    "HTTP/1.1"
+    ":version",
+    "HTTP/1.1",
+    ":path",
+    req.get(),
+    ":host",
+    host.get(),
+    ":scheme",
+    scheme.get(),
   };
   return ConstructSpdyControlFrame(extra_headers,
                                    extra_header_count,
                                    false,
                                    stream_id,
                                    LOWEST,
                                    SYN_STREAM,
                                    CONTROL_FLAG_NONE,
-                                   kStandardGetHeaders,
-                                   arraysize(kStandardGetHeaders),
+                                   headers,
+                                   arraysize(headers),
                                    associated_stream_id);
 
 }
 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) {
+  GURL gurl(url);
+
+  std::string str_path = gurl.PathForRequest();
+  std::string str_scheme = gurl.scheme();
+  std::string str_host = gurl.host();
+  if (gurl.has_port()) {
+    str_host += ":";
+    str_host += gurl.port();
+  }
+  scoped_array<char> req(new char[str_path.size() + 1]);
+  scoped_array<char> scheme(new char[str_scheme.size() + 1]);
+  scoped_array<char> host(new char[str_host.size() + 1]);
+  memcpy(req.get(), str_path.c_str(), str_path.size());
+  memcpy(scheme.get(), str_scheme.c_str(), str_scheme.size());
+  memcpy(host.get(), str_host.c_str(), str_host.size());
+  req.get()[str_path.size()] = '\0';
+  scheme.get()[str_scheme.size()] = '\0';
+  host.get()[str_host.size()] = '\0';
+
   const char* const kStandardGetHeaders[] = {
     "hello",
     "bye",
-    "status",
+    ":status",
     status,
     "location",
     location,
-    "url",
-    url,
-    "version",
+    ":path",
+    req.get(),
+    ":host",
+    host.get(),
+    ":scheme",
+    scheme.get(),
+    ":version",
     "HTTP/1.1"
   };
   return ConstructSpdyControlFrame(extra_headers,
                                    extra_header_count,
                                    false,
                                    stream_id,
                                    LOWEST,
                                    SYN_STREAM,
                                    CONTROL_FLAG_NONE,
                                    kStandardGetHeaders,
                                    arraysize(kStandardGetHeaders),
                                    associated_stream_id);
 }
 
 SpdyFrame* ConstructSpdyPush(int stream_id,
-                                  int associated_stream_id,
-                                  const char* url) {
-  const char* const kStandardGetHeaders[] = {
-    "url",
-    url
+                             int associated_stream_id,
+                             const char* url) {
+  GURL gurl(url);
+
+  std::string str_path = gurl.PathForRequest();
+  std::string str_scheme = gurl.scheme();
+  std::string str_host = gurl.host();
+  if (gurl.has_port()) {
+    str_host += ":";
+    str_host += gurl.port();
+  }
+  scoped_array<char> req(new char[str_path.size() + 1]);
+  scoped_array<char> scheme(new char[str_scheme.size() + 1]);
+  scoped_array<char> host(new char[str_host.size() + 1]);
+  memcpy(req.get(), str_path.c_str(), str_path.size());
+  memcpy(scheme.get(), str_scheme.c_str(), str_scheme.size());
+  memcpy(host.get(), str_host.c_str(), str_host.size());
+  req.get()[str_path.size()] = '\0';
+  scheme.get()[str_scheme.size()] = '\0';
+  host.get()[str_host.size()] = '\0';
+
+  const char* const headers[] = {
+    req.get(),
+    ":host",
+    host.get(),
+    ":scheme",
+    scheme.get(),
   };
   return ConstructSpdyControlFrame(0,
                                    0,
                                    false,
                                    stream_id,
                                    LOWEST,
                                    SYN_STREAM,
                                    CONTROL_FLAG_NONE,
-                                   kStandardGetHeaders,
-                                   arraysize(kStandardGetHeaders),
+                                   headers,
+                                   arraysize(headers),
                                    associated_stream_id);
 }
 
 SpdyFrame* ConstructSpdyPushHeaders(int stream_id,
-                                          const char* const extra_headers[],
-                                          int extra_header_count) {
+                                    const char* const extra_headers[],
+                                    int extra_header_count) {
   const char* const kStandardGetHeaders[] = {
-    "status",
+    ":status",
     "200 OK",
-    "version",
+    ":version",
     "HTTP/1.1"
   };
   return ConstructSpdyControlFrame(extra_headers,
                                    extra_header_count,
                                    false,
                                    stream_id,
                                    LOWEST,
                                    HEADERS,
                                    CONTROL_FLAG_NONE,
                                    kStandardGetHeaders,
                                    arraysize(kStandardGetHeaders));
 }
 
 // Constructs a standard SPDY SYN_REPLY packet 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",
     status,
-    "version",
+    ":version",
     "HTTP/1.1"
   };
   return ConstructSpdyControlFrame(extra_headers,
                                    extra_header_count,
                                    false,
                                    stream_id,
                                    LOWEST,
                                    SYN_REPLY,
                                    CONTROL_FLAG_NONE,
                                    kStandardGetHeaders,
@@ skipping 26 matching lines @@
 // 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.
 SpdyFrame* ConstructSpdyGetSynReply(const char* const extra_headers[],
                                           int extra_header_count,
                                           int stream_id) {
   static const char* const kStandardGetHeaders[] = {
     "hello",
     "bye",
-    "status",
+    ":status",
     "200",
-    "version",
+    ":version",
     "HTTP/1.1"
   };
   return ConstructSpdyControlFrame(extra_headers,
                                    extra_header_count,
                                    false,
                                    stream_id,
                                    LOWEST,
                                    SYN_REPLY,
                                    CONTROL_FLAG_NONE,
                                    kStandardGetHeaders,
@@ skipping 65 matching lines @@
 
 // Constructs a standard SPDY SYN_REPLY packet 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",
+    ":status",
     "200",
     "url",
     "/index.php",
-    "version",
+    ":version",
     "HTTP/1.1"
   };
   return ConstructSpdyControlFrame(extra_headers,
                                    extra_header_count,
                                    false,
                                    1,
                                    LOWEST,
                                    SYN_REPLY,
                                    CONTROL_FLAG_NONE,
                                    kStandardGetHeaders,
@@ skipping 42 matching lines @@
     return 0;
   // Copy in the extra headers.
   AppendHeadersToSpdyFrame(extra_headers, extra_header_count, &headers);
   // The iterator gets us the list of header/value pairs in sorted order.
   SpdyHeaderBlock::iterator next = headers.begin();
   SpdyHeaderBlock::iterator last = headers.end();
   for ( ; next != last; ++next) {
     // Write the header.
     int value_len, current_len, offset;
     const char* header_string = next->first.c_str();
+    if (header_string && header_string[0] == ':')
+      header_string++;
     packet_size += AppendToBuffer(header_string,
-                                  next->first.length(),
+                                  //next->first.length(),
+                                  strlen(header_string),
                                   &buffer_write,
                                   &buffer_left);
     packet_size += AppendToBuffer(": ",
                                   strlen(": "),
                                   &buffer_write,
                                   &buffer_left);
     // Write the value(s).
     const char* value_string = next->second.c_str();
     // Check if it's split among two or more values.
     value_len = next->second.length();
@@ skipping 205 matching lines @@
 
 SpdyTestStateHelper::~SpdyTestStateHelper() {
   SpdySession::ResetStaticSettingsToInit();
   // TODO(rch): save/restore this value
   SpdyFramer::set_enable_compression_default(true);
 }
 
 }  // namespace test_spdy3
 
 }  // namespace net