Stop using SpdySynReplyIR for SPDY 4.

net/spdy/spdy_network_transaction_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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
@@ skipping 1681 matching lines @@
     DATA_FLAG_NONE          // Data Flags
   };
   scoped_ptr<SpdyHeaderBlock> put_headers(
       spdy_util_.ConstructPutHeaderBlock("http://www.google.com", 0));
   scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyFrame(
       kSynStartHeader, put_headers.Pass()));
   MockWrite writes[] = {
     CreateMockWrite(*req),
   };
 
+  scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
-  const SpdyHeaderInfo kSynReplyHeader = {
-    SYN_REPLY,              // Kind = SynReply
-    1,                      // Stream ID
-    0,                      // Associated stream ID
-    ConvertRequestPriorityToSpdyPriority(
-        LOWEST, spdy_util_.spdy_version()),
-    kSpdyCredentialSlotUnused,
-    CONTROL_FLAG_NONE,      // Control Flags
-    false,                  // Compressed
-    RST_STREAM_INVALID,     // Status
-    NULL,                   // Data
-    0,                      // Length
-    DATA_FLAG_NONE          // Data Flags
-  };
-  scoped_ptr<SpdyHeaderBlock> reply_headers(new SpdyHeaderBlock());
-  (*reply_headers)[spdy_util_.GetStatusKey()] = "200";
-  (*reply_headers)[spdy_util_.GetVersionKey()] = "HTTP/1.1";
-  (*reply_headers)["content-length"] = "1234";
-  scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyFrame(
-      kSynReplyHeader, reply_headers.Pass()));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body),
     MockRead(ASYNC, 0, 0)  // EOF
   };
 
   DelayedSocketData data(1, reads, arraysize(reads),
                          writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
@@ skipping 26 matching lines @@
     DATA_FLAG_NONE          // Data Flags
   };
   scoped_ptr<SpdyHeaderBlock> head_headers(
       spdy_util_.ConstructHeadHeaderBlock("http://www.google.com", 0));
   scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyFrame(
       kSynStartHeader, head_headers.Pass()));
   MockWrite writes[] = {
     CreateMockWrite(*req),
   };
 
+  scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
-  const SpdyHeaderInfo kSynReplyHeader = {
-    SYN_REPLY,              // Kind = SynReply
-    1,                      // Stream ID
-    0,                      // Associated stream ID
-    ConvertRequestPriorityToSpdyPriority(
-        LOWEST, spdy_util_.spdy_version()),
-    kSpdyCredentialSlotUnused,
-    CONTROL_FLAG_NONE,      // Control Flags
-    false,                  // Compressed
-    RST_STREAM_INVALID,     // Status
-    NULL,                   // Data
-    0,                      // Length
-    DATA_FLAG_NONE          // Data Flags
-  };
-  scoped_ptr<SpdyHeaderBlock> reply_headers(new SpdyHeaderBlock());
-  (*reply_headers)[spdy_util_.GetStatusKey()] = "200";
-  (*reply_headers)[spdy_util_.GetVersionKey()] = "HTTP/1.1";
-  (*reply_headers)["content-length"] = "1234";
-  scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyFrame(
-      kSynReplyHeader,
-      reply_headers.Pass()));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body),
     MockRead(ASYNC, 0, 0)  // EOF
   };
 
   DelayedSocketData data(1, reads, arraysize(reads),
                          writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
@@ skipping 1563 matching lines @@
         header_block[name] += value;
       }
     }
     EXPECT_EQ(test_cases[i].expected_headers, header_block);
   }
 }
 
 // Verify that various SynReply headers parse vary fields correctly
 // through the HTTP layer, and the response matches the request.
 TEST_P(SpdyNetworkTransactionTest, SynReplyHeadersVary) {
-  static const SpdyHeaderInfo syn_reply_info = {
-    SYN_REPLY,                              // Syn Reply
-    1,                                      // Stream ID
-    0,                                      // Associated Stream ID
-    ConvertRequestPriorityToSpdyPriority(
-        LOWEST, spdy_util_.spdy_version()),
-    kSpdyCredentialSlotUnused,
-    CONTROL_FLAG_NONE,                      // Control Flags
-    false,                                  // Compressed
-    RST_STREAM_INVALID,                     // Status
-    NULL,                                   // Data
-    0,                                      // Data Length
-    DATA_FLAG_NONE                          // Data Flags
-  };
   // Modify the following data to change/add test cases:
   struct SynReplyTests {
-    const SpdyHeaderInfo* syn_reply;
     bool vary_matches;
     int num_headers[2];
     const char* extra_headers[2][16];
   } 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",
           spdy_util_.GetStatusKey(), "200",
           spdy_util_.GetPathKey(),      "/index.php",
           spdy_util_.GetVersionKey(), "HTTP/1.1",
           NULL
         }
       }
     }, {    // Multiple vary fields.
-      &syn_reply_info,
       true,
       { 2, 5 },
       { { "friend",   "barney",
           "enemy",    "snaggletooth",
           NULL
         },
         { "vary",     "friend",
           "vary",     "enemy",
           spdy_util_.GetStatusKey(), "200",
           spdy_util_.GetPathKey(),      "/index.php",
           spdy_util_.GetVersionKey(), "HTTP/1.1",
           NULL
         }
       }
     }, {    // Test a '*' vary field.
-      &syn_reply_info,
       false,
       { 1, 4 },
       { { "cookie",   "val1,val2",
           NULL
         },
         { "vary",     "*",
           spdy_util_.GetStatusKey(), "200",
           spdy_util_.GetPathKey(),      "/index.php",
           spdy_util_.GetVersionKey(), "HTTP/1.1",
           NULL
         }
       }
     }, {    // Multiple comma-separated vary fields.
-      &syn_reply_info,
       true,
       { 2, 4 },
       { { "friend",   "barney",
           "enemy",    "snaggletooth",
           NULL
         },
         { "vary",     "friend,enemy",
           spdy_util_.GetStatusKey(), "200",
           spdy_util_.GetPathKey(),      "/index.php",
           spdy_util_.GetVersionKey(), "HTTP/1.1",
           NULL
         }
       }
     }
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
     // Construct the request.
     scoped_ptr<SpdyFrame> frame_req(
         spdy_util_.ConstructSpdyGet(test_cases[i].extra_headers[0],
                                     test_cases[i].num_headers[0],
                                     false, 1, LOWEST, true));
 
     MockWrite writes[] = {
       CreateMockWrite(*frame_req),
     };
 
     // Construct the reply.
+    SpdyHeaderBlock reply_headers;
+    AppendToHeaderBlock(test_cases[i].extra_headers[1],
+                        test_cases[i].num_headers[1],
+                        &reply_headers);
     scoped_ptr<SpdyFrame> frame_reply(
-      spdy_util_.ConstructSpdyFrame(*test_cases[i].syn_reply,
-                                    test_cases[i].extra_headers[1],
-                                    test_cases[i].num_headers[1],
-                                    NULL,
-                                    0));
+        spdy_util_.ConstructSpdyReply(1, reply_headers));
 
     scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
     MockRead reads[] = {
       CreateMockRead(*frame_reply),
       CreateMockRead(*body),
       MockRead(ASYNC, 0, 0)  // EOF
     };
 
     // Attach the headers to the request.
     int header_count = test_cases[i].num_headers[0];
@@ skipping 34 matching lines @@
     void* iter = NULL;
     std::string name, value, lines;
     while (headers->EnumerateHeaderLines(&iter, &name, &value)) {
       lines.append(name);
       lines.append(": ");
       lines.append(value);
       lines.append("\n");
     }
 
     // Construct the expected header reply string.
-    SpdyHeaderBlock reply_headers;
-    AppendToHeaderBlock(test_cases[i].extra_headers[1],
-                        test_cases[i].num_headers[1],
-                        &reply_headers);
     std::string expected_reply =
         spdy_util_.ConstructSpdyReplyString(reply_headers);
     EXPECT_EQ(expected_reply, lines) << i;
   }
 }
 
 // Verify that we don't crash on invalid SynReply responses.
 TEST_P(SpdyNetworkTransactionTest, InvalidSynReply) {
-  const SpdyHeaderInfo kSynStartHeader = {
-    SYN_REPLY,              // Kind = SynReply
-    1,                      // Stream ID
-    0,                      // Associated stream ID
-    ConvertRequestPriorityToSpdyPriority(
-        LOWEST, spdy_util_.spdy_version()),
-    kSpdyCredentialSlotUnused,
-    CONTROL_FLAG_NONE,      // Control Flags
-    false,                  // Compressed
-    RST_STREAM_INVALID,     // Status
-    NULL,                   // Data
-    0,                      // Length
-    DATA_FLAG_NONE          // Data Flags
-  };
-
   struct InvalidSynReplyTests {
     int num_headers;
     const char* headers[10];
   } test_cases[] = {
     // SYN_REPLY missing status header
     { 4,
       { "cookie", "val1",
         "cookie", "val2",
         spdy_util_.GetPathKey(), "/index.php",
         spdy_util_.GetVersionKey(), "HTTP/1.1",
@@ skipping 14 matching lines @@
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
     scoped_ptr<SpdyFrame> req(
         spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
     scoped_ptr<SpdyFrame> rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR));
     MockWrite writes[] = {
       CreateMockWrite(*req),
       CreateMockWrite(*rst),
     };
 
-    scoped_ptr<SpdyFrame> resp(
-       spdy_util_.ConstructSpdyFrame(kSynStartHeader,
-                                     NULL, 0,
-                                     test_cases[i].headers,
-                                     test_cases[i].num_headers));
-    scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
+    // Construct the reply.
+    SpdyHeaderBlock reply_headers;
+    AppendToHeaderBlock(
+        test_cases[i].headers, test_cases[i].num_headers, &reply_headers);
+    scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyReply(1, reply_headers));
     MockRead reads[] = {
       CreateMockRead(*resp),
       MockRead(ASYNC, 0, 0)  // EOF
     };
 
     DelayedSocketData data(1, reads, arraysize(reads),
                            writes, arraysize(writes));
     NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                        BoundNetLog(), GetParam(), NULL);
     helper.RunToCompletion(&data);
@@ skipping 516 matching lines @@
 
 // Verify the case where we buffer data but read it after it has been buffered.
 TEST_P(SpdyNetworkTransactionTest, BufferedAll) {
   BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
 
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   MockWrite writes[] = { CreateMockWrite(*req) };
 
   // 5 data frames in a single read.
-  SpdySynReplyIR reply_ir(1);
-  reply_ir.SetHeader(spdy_util_.GetStatusKey(), "200");
-  reply_ir.SetHeader(spdy_util_.GetVersionKey(), "HTTP/1.1");
-
-  scoped_ptr<SpdyFrame> syn_reply(framer.SerializeFrame(reply_ir));
+  scoped_ptr<SpdyFrame> reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> data_frame(
       framer.CreateDataFrame(1, "message", 7, DATA_FLAG_NONE));
   scoped_ptr<SpdyFrame> data_frame_fin(
       framer.CreateDataFrame(1, "message", 7, DATA_FLAG_FIN));
-  const SpdyFrame* frames[5] = {
-    syn_reply.get(),
-    data_frame.get(),
-    data_frame.get(),
-    data_frame.get(),
-    data_frame_fin.get()
-  };
+  const SpdyFrame* frames[5] = {reply.get(), data_frame.get(), data_frame.get(),
+                                data_frame.get(), data_frame_fin.get()};
   char combined_frames[200];
   int combined_frames_len =
       CombineFrames(frames, arraysize(frames),
                     combined_frames, arraysize(combined_frames));
 
   MockRead reads[] = {
     MockRead(ASYNC, combined_frames, combined_frames_len),
     MockRead(ASYNC, 0, 0)  // EOF
   };
 
@@ skipping 212 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   // Verify that we consumed all test data.
   helper.VerifyDataConsumed();
 }
 
 // Test that if the server requests persistence of settings, that we save
 // the settings in the HttpServerProperties.
 TEST_P(SpdyNetworkTransactionTest, SettingsSaved) {
   if (spdy_util_.spdy_version() >= SPDY4) {
-    // SPDY4 doesn't support flags on individual settings, and
-    // has no concept of settings persistence.
+    // SPDY4 doesn't support settings persistence.
     return;
   }
   static const SpdyHeaderInfo kSynReplyInfo = {
     SYN_REPLY,                              // Syn Reply
     1,                                      // Stream ID
     0,                                      // Associated Stream ID
     ConvertRequestPriorityToSpdyPriority(
         LOWEST, spdy_util_.spdy_version()),
     kSpdyCredentialSlotUnused,
     CONTROL_FLAG_NONE,                      // Control Flags
@@ skipping 86 matching lines @@
     EXPECT_TRUE(it3 != settings_map.end());
     SettingsFlagsAndValue flags_and_value3 = it3->second;
     EXPECT_EQ(SETTINGS_FLAG_PERSISTED, flags_and_value3.first);
     EXPECT_EQ(kSampleValue3, flags_and_value3.second);
   }
 }
 
 // Test that when there are settings saved that they are sent back to the
 // server upon session establishment.
 TEST_P(SpdyNetworkTransactionTest, SettingsPlayback) {
-  // TODO(jgraettinger): Remove settings persistence mechanisms altogether.
+  if (spdy_util_.spdy_version() >= SPDY4) {
+    // SPDY4 doesn't support settings persistence.
+    return;
+  }
   static const SpdyHeaderInfo kSynReplyInfo = {
     SYN_REPLY,                              // Syn Reply
     1,                                      // Stream ID
     0,                                      // Associated Stream ID
     ConvertRequestPriorityToSpdyPriority(
         LOWEST, spdy_util_.spdy_version()),
     kSpdyCredentialSlotUnused,
     CONTROL_FLAG_NONE,                      // Control Flags
     false,                                  // Compressed
     RST_STREAM_INVALID,                     // Status
@@ skipping 1107 matching lines @@
   EXPECT_TRUE(data.at_read_eof());
   EXPECT_TRUE(data.at_write_eof());
 }
 
 TEST_P(SpdyNetworkTransactionTest, SynReplyWithHeaders) {
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR));
   MockWrite writes[] = {
-    CreateMockWrite(*req),
-    CreateMockWrite(*rst),
- };
+      CreateMockWrite(*req), CreateMockWrite(*rst),
+  };
 
-  scoped_ptr<SpdyHeaderBlock> initial_headers(new SpdyHeaderBlock());
-  (*initial_headers)[spdy_util_.GetStatusKey()] = "200 OK";
-  (*initial_headers)[spdy_util_.GetVersionKey()] = "HTTP/1.1";
   scoped_ptr<SpdyFrame> stream1_reply(
-      spdy_util_.ConstructSpdyControlFrame(initial_headers.Pass(),
-                                           false,
-                                           1,
-                                           LOWEST,
-                                           SYN_REPLY,
-                                           CONTROL_FLAG_NONE,
-                                           0));
+      spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
 
   scoped_ptr<SpdyHeaderBlock> late_headers(new SpdyHeaderBlock());
   (*late_headers)["hello"] = "bye";
   scoped_ptr<SpdyFrame> stream1_headers(
       spdy_util_.ConstructSpdyControlFrame(late_headers.Pass(),
                                            false,
                                            1,
                                            LOWEST,
                                            HEADERS,
                                            CONTROL_FLAG_NONE,
@@ skipping 19 matching lines @@
 TEST_P(SpdyNetworkTransactionTest, SynReplyWithLateHeaders) {
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR));
   MockWrite writes[] = {
     CreateMockWrite(*req),
     CreateMockWrite(*rst),
   };
 
-  scoped_ptr<SpdyHeaderBlock> initial_headers(new SpdyHeaderBlock());
-  (*initial_headers)[spdy_util_.GetStatusKey()] = "200 OK";
-  (*initial_headers)[spdy_util_.GetVersionKey()] = "HTTP/1.1";
   scoped_ptr<SpdyFrame> stream1_reply(
-      spdy_util_.ConstructSpdyControlFrame(initial_headers.Pass(),
-                                           false,
-                                           1,
-                                           LOWEST,
-                                           SYN_REPLY,
-                                           CONTROL_FLAG_NONE,
-                                           0));
+      spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
 
   scoped_ptr<SpdyHeaderBlock> late_headers(new SpdyHeaderBlock());
   (*late_headers)["hello"] = "bye";
   scoped_ptr<SpdyFrame> stream1_headers(
       spdy_util_.ConstructSpdyControlFrame(late_headers.Pass(),
                                            false,
                                            1,
                                            LOWEST,
                                            HEADERS,
                                            CONTROL_FLAG_NONE,
@@ skipping 1010 matching lines @@
 TEST_P(SpdyNetworkTransactionTLSUsageCheckTest, TLSCipherSuiteSucky) {
   scoped_ptr<SSLSocketDataProvider> ssl_provider(
       new SSLSocketDataProvider(ASYNC, OK));
   // Set to TLS_RSA_WITH_NULL_MD5
   SSLConnectionStatusSetCipherSuite(0x1, &ssl_provider->connection_status);
 
   RunTLSUsageCheckTest(ssl_provider.Pass());
 }
 
 }  // namespace net