Properly handle spdy3 responses.

net/spdy/spdy_network_transaction_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 "net/http/http_network_transaction.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 1460 matching lines @@
     0,                      // Associated stream ID
     net::ConvertRequestPriorityToSpdyPriority(LOWEST),  // Priority
     0,                      // Credential Slot
     CONTROL_FLAG_NONE,      // Control Flags
     false,                  // Compressed
     INVALID,                // Status
     NULL,                   // Data
     0,                      // Length
     DATA_FLAG_NONE          // Data Flags
   };
-  static const char* const kStandardGetHeaders[] = {
-    "status", "200",
-    "version", "HTTP/1.1"
+  static const char* const kStandardRespHeaders[] = {
+    ":status", "200",
+    ":version", "HTTP/1.1"
     "content-length", "1234"
   };
   scoped_ptr<SpdyFrame> resp(ConstructSpdyPacket(kSynReplyHeader,
-      NULL, 0, kStandardGetHeaders, arraysize(kStandardGetHeaders) / 2));
+      NULL, 0, kStandardRespHeaders, arraysize(kStandardRespHeaders) / 2));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body),
     MockRead(ASYNC, 0, 0)  // EOF
   };
 
   scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(request,
@@ skipping 46 matching lines @@
     0,                      // Associated stream ID
     net::ConvertRequestPriorityToSpdyPriority(LOWEST),  // Priority
     0,                      // Credential Slot
     CONTROL_FLAG_NONE,      // Control Flags
     false,                  // Compressed
     INVALID,                // Status
     NULL,                   // Data
     0,                      // Length
     DATA_FLAG_NONE          // Data Flags
   };
-  static const char* const kStandardGetHeaders[] = {
-    "status", "200",
-    "version", "HTTP/1.1"
+  static const char* const kStandardRespHeaders[] = {
+    ":status", "200",
+    ":version", "HTTP/1.1"
     "content-length", "1234"
   };
   scoped_ptr<SpdyFrame> resp(ConstructSpdyPacket(kSynReplyHeader,
-      NULL, 0, kStandardGetHeaders, arraysize(kStandardGetHeaders) / 2));
+      NULL, 0, kStandardRespHeaders, arraysize(kStandardRespHeaders) / 2));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body),
     MockRead(ASYNC, 0, 0)  // EOF
   };
 
   scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(request,
@@ skipping 692 matching lines @@
 TEST_P(SpdyNetworkTransactionSpdy3Test, ResetPushWithTransferEncoding) {
   // Construct the request.
   scoped_ptr<SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   scoped_ptr<SpdyFrame> rst(ConstructSpdyRstStream(2, PROTOCOL_ERROR));
   MockWrite writes[] = {
     CreateMockWrite(*req),
     CreateMockWrite(*rst),
   };
 
   scoped_ptr<SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
-  const char* const headers[] = {"url", "http://www.google.com/1",
+  const char* const headers[] = {":scheme", "http",
+                                 ":host", "www.google.com",
+                                 ":path", "/1",
                                  "transfer-encoding", "chunked"};
   scoped_ptr<SpdyFrame> push(ConstructSpdyPush(headers, arraysize(headers) / 2,
                                                2, 1));
   scoped_ptr<SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*push),
     CreateMockRead(*body),
     MockRead(ASYNC, 0, 0)  // EOF
   };
@@ skipping 287 matching lines @@
         new SpdyURLRequestContext();
     r.set_context(spdy_url_request_context);
     spdy_url_request_context->socket_factory().
         AddSocketDataProvider(data.get());
     spdy_url_request_context->socket_factory().
         AddSocketDataProvider(data2.get());
 
     d.set_quit_on_redirect(true);
     r.Start();
     MessageLoop::current()->Run();
-
     EXPECT_EQ(1, d.received_redirect_count());
 
     r.FollowDeferredRedirect();
     MessageLoop::current()->Run();
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(net::URLRequestStatus::SUCCESS, r.status().status());
     std::string contents("hello!");
     EXPECT_EQ(contents, d.data_received());
   }
@@ skipping 42 matching lines @@
   scoped_ptr<SpdyFrame>
       syn(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   scoped_ptr<SpdyFrame>
       rst(ConstructSpdyRstStream(1, PROTOCOL_ERROR));
   MockWrite writes[] = {
     CreateMockWrite(*syn, 0),
     CreateMockWrite(*rst, 2),
   };
 
   static const char* const kInitialHeaders[] = {
-    "status", "200 OK",
-    "version", "HTTP/1.1"
+    ":status", "200 OK",
+    ":version", "HTTP/1.1"
   };
   static const char* const kLateHeaders[] = {
     "X-UpperCase", "yes",
   };
   scoped_ptr<SpdyFrame>
       stream1_reply(ConstructSpdyControlFrame(kInitialHeaders,
                                               arraysize(kInitialHeaders) / 2,
                                               false,
                                               1,
                                               LOWEST,
@@ skipping 37 matching lines @@
       syn(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   scoped_ptr<SpdyFrame>
       rst(ConstructSpdyRstStream(2, PROTOCOL_ERROR));
   MockWrite writes[] = {
     CreateMockWrite(*syn, 0),
     CreateMockWrite(*rst, 2),
   };
 
   scoped_ptr<SpdyFrame>
       reply(ConstructSpdyGetSynReply(NULL, 0, 1));
-  const char* const extra_headers[] = {"X-UpperCase", "yes"};
+  const char* const extra_headers[] = {
+    "X-UpperCase", "yes"
+  };
   scoped_ptr<SpdyFrame>
-      push(ConstructSpdyPush(extra_headers, 1, 2, 1));
+      push(ConstructSpdyPush(extra_headers, arraysize(extra_headers) / 2,
+                             2, 1));
   scoped_ptr<SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*reply, 1),
     CreateMockRead(*push, 1),
     CreateMockRead(*body, 1),
     MockRead(ASYNC, ERR_IO_PENDING, 3),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
@@ skipping 750 matching lines @@
     int num_headers;
     const char* extra_headers[5];
     const char* expected_headers;
   } test_cases[] = {
     // This uses a multi-valued cookie header.
     { 2,
       { "cookie", "val1",
         "cookie", "val2",  // will get appended separated by NULL
         NULL
       },
+      "status: 200\n"
+      "version: HTTP/1.1\n"
       "cookie: val1\n"
       "cookie: val2\n"
       "hello: bye\n"
-      "status: 200\n"
-      "version: HTTP/1.1\n"
     },
     // This is the minimalist set of headers.
     { 0,
       { NULL },
-      "hello: bye\n"
       "status: 200\n"
       "version: HTTP/1.1\n"
+      "hello: bye\n"
     },
     // Headers with a comma separated list.
     { 1,
       { "cookie", "val1,val2",
         NULL
       },
+      "status: 200\n"
+      "version: HTTP/1.1\n"
       "cookie: val1,val2\n"
       "hello: bye\n"
-      "status: 200\n"
-      "version: HTTP/1.1\n"
     }
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
     scoped_ptr<SpdyFrame> req(
         ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
     MockWrite writes[] = { CreateMockWrite(*req) };
 
     scoped_ptr<SpdyFrame> resp(
         ConstructSpdyGetSynReply(test_cases[i].extra_headers,
@@ skipping 57 matching lines @@
   } test_cases[] = {
     // Test the case of a multi-valued cookie.  When the value is delimited
     // with NUL characters, it needs to be unfolded into multiple headers.
     {
       &syn_reply_info,
       true,
       { 1, 4 },
       { { "cookie",   "val1,val2",
           NULL
         },
-        { "vary",     "cookie",
-          "status",   "200",
+        { ":status",   "200",
+          ":version",  "HTTP/1.1",
+          "vary",     "cookie",
           "url",      "/index.php",
-          "version",  "HTTP/1.1",
           NULL
         }
       }
     }, {    // Multiple vary fields.
       &syn_reply_info,
       true,
       { 2, 5 },
       { { "friend",   "barney",
           "enemy",    "snaggletooth",
           NULL
         },
-        { "vary",     "friend",
+        { ":status",   "200",
+          ":version",  "HTTP/1.1",
+          "vary",     "friend",
           "vary",     "enemy",
-          "status",   "200",
           "url",      "/index.php",
-          "version",  "HTTP/1.1",
           NULL
         }
       }
     }, {    // Test a '*' vary field.
       &syn_reply_info,
       false,
       { 1, 4 },
       { { "cookie",   "val1,val2",
           NULL
         },
-        { "vary",     "*",
-          "status",   "200",
+        { ":status",   "200",
+          ":version",  "HTTP/1.1",
+          "vary",     "*",
           "url",      "/index.php",
-          "version",  "HTTP/1.1",
           NULL
         }
       }
     }, {    // Multiple comma-separated vary fields.
       &syn_reply_info,
       true,
       { 2, 4 },
       { { "friend",   "barney",
           "enemy",    "snaggletooth",
           NULL
         },
-        { "vary",     "friend,enemy",
-          "status",   "200",
+        { ":status",   "200",
+          ":version",  "HTTP/1.1",
+          "vary",     "friend,enemy",
           "url",      "/index.php",
-          "version",  "HTTP/1.1",
           NULL
         }
       }
     }
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
     // Construct the request.
     scoped_ptr<SpdyFrame> frame_req(
       ConstructSpdyGet(test_cases[i].extra_headers[0],
@@ skipping 100 matching lines @@
     { 4,
       { "cookie", "val1",
         "cookie", "val2",
         "url", "/index.php",
         "version", "HTTP/1.1",
         NULL
       },
     },
     // SYN_REPLY missing version header
     { 2,
-      { "status", "200",
+      { ":status", "200",
         "url", "/index.php",
         NULL
       },
     },
     // SYN_REPLY with no headers
     { 0, { NULL }, },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
     scoped_ptr<SpdyFrame> req(
@@ skipping 685 matching lines @@
     net::ConvertRequestPriorityToSpdyPriority(LOWEST),  // Priority
     0,                                      // Credential Slot
     CONTROL_FLAG_NONE,                      // Control Flags
     false,                                  // Compressed
     INVALID,                                // Status
     NULL,                                   // Data
     0,                                      // Data Length
     DATA_FLAG_NONE                          // Data Flags
   };
   static const char* const kExtraHeaders[] = {
-    "status",   "200",
-    "version",  "HTTP/1.1"
+    ":status",   "200",
+    ":version",  "HTTP/1.1"
   };
 
   BoundNetLog net_log;
   NormalSpdyTransactionHelper helper(CreateGetRequest(), net_log, GetParam());
   helper.RunPreTestSetup();
 
   // Verify that no settings exist initially.
   HostPortPair host_port_pair("www.google.com", helper.port());
   SpdySessionPool* spdy_session_pool = helper.session()->spdy_session_pool();
   EXPECT_TRUE(spdy_session_pool->http_server_properties()->GetSpdySettings(
@@ skipping 85 matching lines @@
     net::ConvertRequestPriorityToSpdyPriority(LOWEST),  // Priority
     0,                                      // Credential Slot
     CONTROL_FLAG_NONE,                      // Control Flags
     false,                                  // Compressed
     INVALID,                                // Status
     NULL,                                   // Data
     0,                                      // Data Length
     DATA_FLAG_NONE                          // Data Flags
   };
   static const char* kExtraHeaders[] = {
-    "status",   "200",
-    "version",  "HTTP/1.1"
+    ":status",   "200",
+    ":version",  "HTTP/1.1"
   };
 
   BoundNetLog net_log;
   NormalSpdyTransactionHelper helper(CreateGetRequest(), net_log, GetParam());
   helper.RunPreTestSetup();
 
   // Verify that no settings exist initially.
   HostPortPair host_port_pair("www.google.com", helper.port());
   SpdySessionPool* spdy_session_pool = helper.session()->spdy_session_pool();
   EXPECT_TRUE(spdy_session_pool->http_server_properties()->GetSpdySettings(
@@ skipping 662 matching lines @@
   };
   scoped_ptr<SpdyFrame>
       stream1_syn(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   scoped_ptr<SpdyFrame>
       stream1_body(ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
     CreateMockWrite(*stream1_syn, 1),
   };
 
   static const char* const kInitialHeaders[] = {
-    "url",
-    "http://www.google.com/foo.dat",
+    ":scheme", "http",
+    ":host", "www.google.com",
+    ":path", "/foo.dat",
   };
   static const char* const kLateHeaders[] = {
     "hello",
     "bye",
-    "status",
+    ":status",
     "200",
-    "version",
+    ":version",
     "HTTP/1.1"
   };
   scoped_ptr<SpdyFrame>
     stream2_syn(ConstructSpdyControlFrame(kInitialHeaders,
                                           arraysize(kInitialHeaders) / 2,
                                           false,
                                           2,
                                           LOWEST,
                                           SYN_STREAM,
                                           CONTROL_FLAG_NONE,
@@ skipping 55 matching lines @@
   };
   scoped_ptr<SpdyFrame>
       stream1_syn(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   scoped_ptr<SpdyFrame>
       stream1_body(ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
     CreateMockWrite(*stream1_syn, 0, SYNCHRONOUS),
   };
 
   static const char* const kInitialHeaders[] = {
-    "url",
-    "http://www.google.com/foo.dat",
+    ":scheme", "http",
+    ":host", "www.google.com",
+    ":path", "/foo.dat"
   };
   static const char* const kLateHeaders[] = {
     "hello",
     "bye",
-    "status",
+    ":status",
     "200",
-    "version",
+    ":version",
     "HTTP/1.1"
   };
   scoped_ptr<SpdyFrame>
       stream2_syn(ConstructSpdyControlFrame(kInitialHeaders,
                                             arraysize(kInitialHeaders) / 2,
                                             false,
                                             2,
                                             LOWEST,
                                             SYN_STREAM,
                                             CONTROL_FLAG_NONE,
@@ skipping 108 matching lines @@
   };
   scoped_ptr<SpdyFrame>
       stream1_syn(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   scoped_ptr<SpdyFrame>
       stream1_body(ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
     CreateMockWrite(*stream1_syn, 0, SYNCHRONOUS),
   };
 
   static const char* const kInitialHeaders[] = {
-    "url",
-    "http://www.google.com/foo.dat",
+    ":scheme", "http",
+    ":host", "www.google.com",
+    ":path", "/foo.dat"
   };
   static const char* const kMiddleHeaders[] = {
     "hello",
     "bye",
   };
   static const char* const kLateHeaders[] = {
-    "status",
+    ":status",
     "200",
-    "version",
+    ":version",
     "HTTP/1.1"
   };
   scoped_ptr<SpdyFrame>
       stream2_syn(ConstructSpdyControlFrame(kInitialHeaders,
                                             arraysize(kInitialHeaders) / 2,
                                             false,
                                             2,
                                             LOWEST,
                                             SYN_STREAM,
                                             CONTROL_FLAG_NONE,
@@ skipping 105 matching lines @@
   // Verify the SYN_REPLY.
   EXPECT_TRUE(response.headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
   EXPECT_TRUE(response2.headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
 
   // Verify we got all the headers
   EXPECT_TRUE(response2.headers->HasHeaderValue(
-      "url",
-      "http://www.google.com/foo.dat"));
+      "scheme", "http"));
+  EXPECT_TRUE(response2.headers->HasHeaderValue(
+      "host", "www.google.com"));
+  EXPECT_TRUE(response2.headers->HasHeaderValue(
+      "path", "/foo.dat"));
   EXPECT_TRUE(response2.headers->HasHeaderValue("hello", "bye"));
   EXPECT_TRUE(response2.headers->HasHeaderValue("status", "200"));
   EXPECT_TRUE(response2.headers->HasHeaderValue("version", "HTTP/1.1"));
 }
 
 TEST_P(SpdyNetworkTransactionSpdy3Test, SynReplyWithHeaders) {
   scoped_ptr<SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   MockWrite writes[] = { CreateMockWrite(*req) };
 
   static const char* const kInitialHeaders[] = {
-    "status",
+    ":status",
     "200 OK",
-    "version",
+    ":version",
     "HTTP/1.1"
   };
   static const char* const kLateHeaders[] = {
     "hello",
     "bye",
   };
   scoped_ptr<SpdyFrame>
       stream1_reply(ConstructSpdyControlFrame(kInitialHeaders,
                                               arraysize(kInitialHeaders) / 2,
                                               false,
@@ skipping 33 matching lines @@
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
 TEST_P(SpdyNetworkTransactionSpdy3Test, SynReplyWithLateHeaders) {
   scoped_ptr<SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   MockWrite writes[] = { CreateMockWrite(*req) };
 
   static const char* const kInitialHeaders[] = {
-    "status",
+    ":status",
     "200 OK",
-    "version",
+    ":version",
     "HTTP/1.1"
   };
   static const char* const kLateHeaders[] = {
     "hello",
     "bye",
   };
   scoped_ptr<SpdyFrame>
       stream1_reply(ConstructSpdyControlFrame(kInitialHeaders,
                                               arraysize(kInitialHeaders) / 2,
                                               false,
@@ skipping 35 matching lines @@
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!hello!", out.response_data);
 }
 
 TEST_P(SpdyNetworkTransactionSpdy3Test, SynReplyWithDuplicateLateHeaders) {
   scoped_ptr<SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   MockWrite writes[] = { CreateMockWrite(*req) };
 
   static const char* const kInitialHeaders[] = {
-    "status",
+    ":status",
     "200 OK",
-    "version",
+    ":version",
     "HTTP/1.1"
   };
   static const char* const kLateHeaders[] = {
-    "status",
+    ":status",
     "500 Server Error",
   };
   scoped_ptr<SpdyFrame>
       stream1_reply(ConstructSpdyControlFrame(kInitialHeaders,
                                               arraysize(kInitialHeaders) / 2,
                                               false,
                                               1,
                                               LOWEST,
                                               SYN_REPLY,
                                               CONTROL_FLAG_NONE,
@@ skipping 197 matching lines @@
                                     << " Write index: "
                                     << data->write_index();
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
   EXPECT_TRUE(response.headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 }
 
 }  // namespace net