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

net/spdy/spdy_stream_spdy3_unittest.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 "base/memory/ref_counted.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_log_unittest.h"
 #include "net/spdy/buffered_spdy_framer.h"
 #include "net/spdy/spdy_stream.h"
 #include "net/spdy/spdy_http_utils.h"
@@ skipping 125 matching lines @@
     0,
     net::ConvertRequestPriorityToSpdyPriority(LOWEST),
     spdy::CONTROL_FLAG_NONE,
     false,
     spdy::INVALID,
     NULL,
     0,
     spdy::DATA_FLAG_NONE
   };
   static const char* const kGetHeaders[] = {
-    "method",
+    ":method",
     "GET",
-    "scheme",
+    ":scheme",
     "http",
-    "host",
+    ":host",
     "www.google.com",
-    "path",
+    ":path",
     "/",
-    "version",
+    ":version",
     "HTTP/1.1",
   };
   scoped_ptr<spdy::SpdyFrame> req(
       ConstructSpdyPacket(
           kSynStartHeader, NULL, 0, kGetHeaders, arraysize(kGetHeaders) / 2));
   scoped_ptr<spdy::SpdyFrame> msg(
       ConstructSpdyBodyFrame("\0hello!\xff", 8));
   MockWrite writes[] = {
     CreateMockWrite(*req),
     CreateMockWrite(*msg),
@@ skipping 46 matching lines @@
   memcpy(buf->data(), "\0hello!\xff", 8);
   TestCompletionCallback callback;
 
   scoped_ptr<TestSpdyStreamDelegate> delegate(
       new TestSpdyStreamDelegate(stream.get(), buf.get(), callback.callback()));
   stream->SetDelegate(delegate.get());
 
   EXPECT_FALSE(stream->HasUrl());
 
   linked_ptr<spdy::SpdyHeaderBlock> headers(new spdy::SpdyHeaderBlock);
-  (*headers)["method"] = "GET";
-  (*headers)["scheme"] = url.scheme();
-  (*headers)["host"] = url.host();
-  (*headers)["path"] = url.path();
-  (*headers)["version"] = "HTTP/1.1";
+  (*headers)[":method"] = "GET";
+  (*headers)[":scheme"] = url.scheme();
+  (*headers)[":host"] = url.host();
+  (*headers)[":path"] = url.path();
+  (*headers)[":version"] = "HTTP/1.1";
   stream->set_spdy_headers(headers);
   EXPECT_TRUE(stream->HasUrl());
   EXPECT_EQ(kStreamUrl, stream->GetUrl().spec());
 
   EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(true));
 
   EXPECT_EQ(OK, callback.WaitForResult());
 
   EXPECT_TRUE(delegate->send_headers_completed());
   EXPECT_EQ("200", (*delegate->response())["status"]);
   EXPECT_EQ("HTTP/1.1", (*delegate->response())["version"]);
   EXPECT_EQ(std::string("\0hello!\xff", 8), delegate->received_data());
   EXPECT_EQ(8, delegate->data_sent());
   EXPECT_TRUE(delegate->closed());
 }
 
 TEST_F(SpdyStreamSpdy3Test, PushedStream) {
   const char kStreamUrl[] = "http://www.google.com/";
 
   SpdySessionDependencies session_deps;
   session_ = SpdySessionDependencies::SpdyCreateSession(&session_deps);
   SpdySessionPoolPeer pool_peer_(session_->spdy_session_pool());
   scoped_refptr<SpdySession> spdy_session(CreateSpdySession());
+
+  MockRead reads[] = {
+    MockRead(ASYNC, 0, 0), // EOF
+  };
+
+  scoped_ptr<OrderedSocketData> data(
+      new OrderedSocketData(reads, arraysize(reads), NULL, 0));
+  MockConnect connect_data(SYNCHRONOUS, OK);
+  data->set_connect_data(connect_data);
+
+  session_deps.socket_factory->AddSocketDataProvider(data.get());
+  SpdySession::SetSSLMode(false);
+
+  HostPortPair host_port_pair("www.google.com", 80);
+  scoped_refptr<TransportSocketParams> transport_params(
+      new TransportSocketParams(host_port_pair, LOWEST, false, false));
+  scoped_ptr<ClientSocketHandle> connection(new ClientSocketHandle);
+  EXPECT_EQ(OK, connection->Init(host_port_pair.ToString(), transport_params,
+                                 LOWEST, CompletionCallback(),
+                                 session_->GetTransportSocketPool(),
+                                 BoundNetLog()));
+  spdy_session->InitializeWithSocket(connection.release(), false, OK);
   BoundNetLog net_log;
 
   // Conjure up a stream.
   scoped_refptr<SpdyStream> stream = new SpdyStream(spdy_session,
                                                     2,
                                                     true,
                                                     net_log);
   EXPECT_FALSE(stream->response_received());
   EXPECT_FALSE(stream->HasUrl());
 
   // Set a couple of headers.
   spdy::SpdyHeaderBlock response;
-  response["url"] = kStreamUrl;
+  GURL url(kStreamUrl);
+  response[":host"] = url.host();
+  response[":scheme"] = url.scheme();
+  response[":path"] = url.path();
   stream->OnResponseReceived(response);
 
   // Send some basic headers.
   spdy::SpdyHeaderBlock headers;
   response["status"] = "200";
   response["version"] = "OK";
   stream->OnHeaders(headers);
 
   stream->set_response_received();
   EXPECT_TRUE(stream->response_received());
@@ skipping 13 matching lines @@
     0,
     net::ConvertRequestPriorityToSpdyPriority(LOWEST),
     spdy::CONTROL_FLAG_NONE,
     false,
     spdy::INVALID,
     NULL,
     0,
     spdy::DATA_FLAG_NONE
   };
   static const char* const kGetHeaders[] = {
-    "method",
+    ":method",
     "GET",
-    "scheme",
+    ":scheme",
     "http",
-    "host",
+    ":host",
     "www.google.com",
-    "path",
+    ":path",
     "/",
-    "version",
+    ":version",
     "HTTP/1.1",
   };
   scoped_ptr<spdy::SpdyFrame> req(
       ConstructSpdyPacket(
           kSynStartHeader, NULL, 0, kGetHeaders, arraysize(kGetHeaders) / 2));
   scoped_ptr<spdy::SpdyFrame> msg(
       ConstructSpdyBodyFrame("\0hello!\xff", 8));
   MockWrite writes[] = {
     CreateMockWrite(*req),
     CreateMockWrite(*msg),
@@ skipping 48 matching lines @@
   memcpy(buf->data(), "\0hello!\xff", 8);
   TestCompletionCallback callback;
 
   scoped_ptr<TestSpdyStreamDelegate> delegate(
       new TestSpdyStreamDelegate(stream.get(), buf.get(), callback.callback()));
   stream->SetDelegate(delegate.get());
 
   EXPECT_FALSE(stream->HasUrl());
 
   linked_ptr<spdy::SpdyHeaderBlock> headers(new spdy::SpdyHeaderBlock);
-  (*headers)["method"] = "GET";
-  (*headers)["scheme"] = url.scheme();
-  (*headers)["host"] = url.host();
-  (*headers)["path"] = url.path();
-  (*headers)["version"] = "HTTP/1.1";
+  (*headers)[":method"] = "GET";
+  (*headers)[":scheme"] = url.scheme();
+  (*headers)[":host"] = url.host();
+  (*headers)[":path"] = url.path();
+  (*headers)[":version"] = "HTTP/1.1";
   stream->set_spdy_headers(headers);
   EXPECT_TRUE(stream->HasUrl());
   EXPECT_EQ(kStreamUrl, stream->GetUrl().spec());
 
   EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(true));
 
   const spdy::SpdyStreamId stream_id = stream->stream_id();
 
   EXPECT_EQ(OK, callback.WaitForResult());
 
@@ skipping 16 matching lines @@
       net::NetLog::PHASE_NONE);
 
   CapturingNetLog::Entry entry = entries[pos];
   NetLogSpdyStreamErrorParameter* request_params =
       static_cast<NetLogSpdyStreamErrorParameter*>(
           entry.extra_parameters.get());
   EXPECT_EQ(stream_id, request_params->stream_id());
 }
 
 }  // namespace net