Switch CreateSpdyHeadersFromHttpRequest to construct the correct headers based on the spdy protocol…

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 355 matching lines @@
   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[] = {
-    "method",
+    ":method",
     "GET",
-    "url",
+    ":path",
     req.get(),
-    "host",
+    ":host",
     host.get(),
-    "scheme",
+    ":scheme",
     scheme.get(),
-    "version",
+    ":version",
     "HTTP/1.1"
   };
   return ConstructSpdyPacket(
       kSynStartHeader,
       NULL,
       0,
       headers,
       arraysize(headers) / 2);
 }
 
@@ skipping 14 matching lines @@
 // |extra_headers| are the extra header-value pairs, which typically
 // will vary the most between calls.
 // Returns a SpdyFrame.
 spdy::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",
+    ":method",
     "GET",
-    "url",
-    (direct ? "/" : "http://www.google.com/"),
-    "host",
+    ":host",
     "www.google.com",
-    "scheme",
+    ":scheme",
     "http",
-    "version",
-    "HTTP/1.1"
+    ":version",
+    "HTTP/1.1",
+    ":path",
+    (direct ? "/" : "/")
   };
   return ConstructSpdyControlFrame(extra_headers,
                                    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",
+    ":method", "CONNECT",
+    ":path", "www.google.com:443",
+    ":host", "www.google.com",
+    ":version", "HTTP/1.1",
   };
   return ConstructSpdyControlFrame(extra_headers,
                                    extra_header_count,
                                    /*compressed*/ false,
                                    stream_id,
                                    LOWEST,
                                    spdy::SYN_STREAM,
                                    spdy::CONTROL_FLAG_NONE,
                                    kConnectHeaders,
                                    arraysize(kConnectHeaders));
@@ skipping 202 matching lines @@
 // Constructs a standard SPDY POST SYN packet.
 // |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.
 spdy::SpdyFrame* ConstructSpdyPost(int64 content_length,
                                    const char* const extra_headers[],
                                    int extra_header_count) {
   std::string length_str = base::Int64ToString(content_length);
   const char* post_headers[] = {
-    "method",
+    ":method",
     "POST",
-    "url",
+    ":path",
     "/",
-    "host",
+    ":host",
     "www.google.com",
-    "scheme",
+    ":scheme",
     "http",
-    "version",
+    ":version",
     "HTTP/1.1",
     "content-length",
     length_str.c_str()
   };
   return ConstructSpdyControlFrame(extra_headers,
                                    extra_header_count,
                                    false,
                                    1,
                                    LOWEST,
                                    spdy::SYN_STREAM,
                                    spdy::CONTROL_FLAG_NONE,
                                    post_headers,
                                    arraysize(post_headers));
 }
 
 // Constructs a chunked transfer SPDY POST SYN packet.
 // |extra_headers| are the extra header-value pairs, which typically
 // will vary the most between calls.
 // Returns a SpdyFrame.
 spdy::SpdyFrame* ConstructChunkedSpdyPost(const char* const extra_headers[],
                                           int extra_header_count) {
   const char* post_headers[] = {
-    "method",
+    ":method",
     "POST",
-    "url",
+    ":path",
     "/",
-    "host",
+    ":host",
     "www.google.com",
-    "scheme",
+    ":scheme",
     "http",
-    "version",
+    ":version",
     "HTTP/1.1"
   };
   return ConstructSpdyControlFrame(extra_headers,
                                    extra_header_count,
                                    false,
                                    1,
                                    LOWEST,
                                    spdy::SYN_STREAM,
                                    spdy::CONTROL_FLAG_NONE,
                                    post_headers,
@@ skipping 281 matching lines @@
     NULL,                         // Data
     0,                            // Length
     spdy::DATA_FLAG_NONE          // Data Flags
   };
   return kHeader;
 }
 
 }  // namespace test_spdy3
 
 }  // namespace net