[SPDY] Refactor tests in preparation for a fix for a session flow control bug

net/spdy/spdy_network_transaction_spdy2_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 19 matching lines @@
 #include "net/spdy/spdy_test_utils.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/platform_test.h"
 
 using namespace net::test_spdy2;
 
 //-----------------------------------------------------------------------------
 
 namespace net {
 
+namespace {
+const char kStreamUrl[] = "http://www.google.com/";

[Ryan Hamilton, 2013/03/18 19:29:23]

nit: kRequestUrl?

[akalin, 2013/03/18 21:38:08]

Done.

+}  // namespace
+
 enum SpdyNetworkTransactionSpdy2TestTypes {
   SPDYNPN,
   SPDYNOSSL,
   SPDYSSL,
 };
 
 class SpdyNetworkTransactionSpdy2Test
     : public ::testing::TestWithParam<SpdyNetworkTransactionSpdy2TestTypes> {
  protected:
 
@@ skipping 475 matching lines @@
     rv = callback.WaitForResult();
 
     // Request the pushed path.
     scoped_ptr<HttpNetworkTransaction> trans2(
         new HttpNetworkTransaction(helper.session()));
     rv = trans2->Start(
         &CreateGetPushRequest(), callback.callback(), BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
     MessageLoop::current()->RunUntilIdle();
 
-    // The data for the pushed path may be coming in more than 1 packet. Compile
+    // The data for the pushed path may be coming in more than 1 frame. Compile
     // the results into a single string.
 
     // Read the server push body.
     std::string result2;
     ReadResult(trans2.get(), data, &result2);
     // Read the response body.
     std::string result;
     ReadResult(trans, data, &result);
 
     // Verify that we consumed all test data.
@@ skipping 950 matching lines @@
     DATA_FLAG_NONE          // Data Flags
   };
   const char* const kPutHeaders[] = {
     "method", "PUT",
     "url", "/",
     "host", "www.google.com",
     "scheme", "http",
     "version", "HTTP/1.1",
     "content-length", "0"
   };
-  scoped_ptr<SpdyFrame> req(ConstructSpdyPacket(kSynStartHeader, NULL, 0,
+  scoped_ptr<SpdyFrame> req(ConstructSpdyFrame(kSynStartHeader, NULL, 0,
     kPutHeaders, arraysize(kPutHeaders) / 2));
   MockWrite writes[] = {
     CreateMockWrite(*req)
   };
 
   scoped_ptr<SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   const SpdyHeaderInfo kSynReplyHeader = {
     SYN_REPLY,              // Kind = SynReply
     1,                      // Stream ID
     0,                      // Associated stream ID
     ConvertRequestPriorityToSpdyPriority(LOWEST, 2),  // Priority
     CONTROL_FLAG_NONE,      // Control Flags
     false,                  // Compressed
     RST_STREAM_INVALID,     // Status
     NULL,                   // Data
     0,                      // Length
     DATA_FLAG_NONE          // Data Flags
   };
   static const char* const kStandardGetHeaders[] = {
     "status", "200",
     "version", "HTTP/1.1"
     "content-length", "1234"
   };
-  scoped_ptr<SpdyFrame> resp(ConstructSpdyPacket(kSynReplyHeader,
+  scoped_ptr<SpdyFrame> resp(ConstructSpdyFrame(kSynReplyHeader,
       NULL, 0, kStandardGetHeaders, arraysize(kStandardGetHeaders) / 2));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body),
     MockRead(ASYNC, 0, 0)  // EOF
   };
 
   DelayedSocketData data(1, reads, arraysize(reads),
                          writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(request,
@@ skipping 25 matching lines @@
     DATA_FLAG_NONE          // Data Flags
   };
   const char* const kHeadHeaders[] = {
     "method", "HEAD",
     "url", "/",
     "host", "www.google.com",
     "scheme", "http",
     "version", "HTTP/1.1",
     "content-length", "0"
   };
-  scoped_ptr<SpdyFrame> req(ConstructSpdyPacket(kSynStartHeader, NULL, 0,
+  scoped_ptr<SpdyFrame> req(ConstructSpdyFrame(kSynStartHeader, NULL, 0,
     kHeadHeaders, arraysize(kHeadHeaders) / 2));
   MockWrite writes[] = {
     CreateMockWrite(*req)
   };
 
   scoped_ptr<SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   const SpdyHeaderInfo kSynReplyHeader = {
     SYN_REPLY,              // Kind = SynReply
     1,                      // Stream ID
     0,                      // Associated stream ID
     ConvertRequestPriorityToSpdyPriority(LOWEST, 2),  // Priority
     CONTROL_FLAG_NONE,      // Control Flags
     false,                  // Compressed
     RST_STREAM_INVALID,     // Status
     NULL,                   // Data
     0,                      // Length
     DATA_FLAG_NONE          // Data Flags
   };
   static const char* const kStandardGetHeaders[] = {
     "status", "200",
     "version", "HTTP/1.1"
     "content-length", "1234"
   };
-  scoped_ptr<SpdyFrame> resp(ConstructSpdyPacket(kSynReplyHeader,
+  scoped_ptr<SpdyFrame> resp(ConstructSpdyFrame(kSynReplyHeader,
       NULL, 0, kStandardGetHeaders, arraysize(kStandardGetHeaders) / 2));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body),
     MockRead(ASYNC, 0, 0)  // EOF
   };
 
   DelayedSocketData data(1, reads, arraysize(reads),
                          writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(request,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
 
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
 }
 
 // Test that a simple POST works.
 TEST_P(SpdyNetworkTransactionSpdy2Test, Post) {
-  scoped_ptr<SpdyFrame> req(ConstructSpdyPost(kUploadDataSize, NULL, 0));
+  scoped_ptr<SpdyFrame> req(
+      ConstructSpdyPost(kStreamUrl, kUploadDataSize, NULL, 0));
   scoped_ptr<SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
     CreateMockWrite(*req),
     CreateMockWrite(*body),  // POST upload frame
   };
 
   scoped_ptr<SpdyFrame> resp(ConstructSpdyPostSynReply(NULL, 0));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body),
     MockRead(ASYNC, 0, 0)  // EOF
   };
 
   DelayedSocketData data(2, reads, arraysize(reads),
                          writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreatePostRequest(),
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
 // Test that a POST with a file works.
 TEST_P(SpdyNetworkTransactionSpdy2Test, FilePost) {
-  scoped_ptr<SpdyFrame> req(ConstructSpdyPost(kUploadDataSize, NULL, 0));
+  scoped_ptr<SpdyFrame> req(
+      ConstructSpdyPost(kStreamUrl, kUploadDataSize, NULL, 0));
   scoped_ptr<SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
     CreateMockWrite(*req),
     CreateMockWrite(*body),  // POST upload frame
   };
 
   scoped_ptr<SpdyFrame> resp(ConstructSpdyPostSynReply(NULL, 0));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body),
     MockRead(ASYNC, 0, 0)  // EOF
   };
 
   DelayedSocketData data(2, reads, arraysize(reads),
                          writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateFilePostRequest(),
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
 // Test that a complex POST works.
 TEST_P(SpdyNetworkTransactionSpdy2Test, ComplexPost) {
-  scoped_ptr<SpdyFrame> req(ConstructSpdyPost(kUploadDataSize, NULL, 0));
+  scoped_ptr<SpdyFrame> req(
+      ConstructSpdyPost(kStreamUrl, kUploadDataSize, NULL, 0));
   scoped_ptr<SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
     CreateMockWrite(*req),
     CreateMockWrite(*body),  // POST upload frame
   };
 
   scoped_ptr<SpdyFrame> resp(ConstructSpdyPostSynReply(NULL, 0));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body),
@@ skipping 99 matching lines @@
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ(expected_response, out.response_data);
 }
 
 // Test that a POST without any post data works.
 TEST_P(SpdyNetworkTransactionSpdy2Test, NullPost) {
   // Setup the request
   HttpRequestInfo request;
   request.method = "POST";
-  request.url = GURL("http://www.google.com/");
+  request.url = GURL(kStreamUrl);
   // Create an empty UploadData.
   request.upload_data_stream = NULL;
 
   // When request.upload_data_stream is NULL for post, content-length is
   // expected to be 0.
-  scoped_ptr<SpdyFrame> req(ConstructSpdyPost(0, NULL, 0));
+  scoped_ptr<SpdyFrame> req(ConstructSpdyPost(kStreamUrl, 0, NULL, 0));
   // Set the FIN bit since there will be no body.
   test::SetFrameFlags(req.get(), CONTROL_FLAG_FIN, kSpdyVersion2);
   MockWrite writes[] = {
     CreateMockWrite(*req),
   };
 
   scoped_ptr<SpdyFrame> resp(ConstructSpdyPostSynReply(NULL, 0));
   scoped_ptr<SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*resp),
@@ skipping 15 matching lines @@
 
 // Test that a simple POST works.
 TEST_P(SpdyNetworkTransactionSpdy2Test, EmptyPost) {
   // Create an empty UploadDataStream.
   ScopedVector<UploadElementReader> element_readers;
   UploadDataStream stream(&element_readers, 0);
 
   // Setup the request
   HttpRequestInfo request;
   request.method = "POST";
-  request.url = GURL("http://www.google.com/");
+  request.url = GURL(kStreamUrl);
   request.upload_data_stream = &stream;
 
   const uint64 kContentLength = 0;
-  scoped_ptr<SpdyFrame> req(ConstructSpdyPost(kContentLength, NULL, 0));
+  scoped_ptr<SpdyFrame> req(
+      ConstructSpdyPost(kStreamUrl, kContentLength, NULL, 0));
   // Set the FIN bit since there will be no body.
   test::SetFrameFlags(req.get(), CONTROL_FLAG_FIN, kSpdyVersion2);
   MockWrite writes[] = {
     CreateMockWrite(*req),
   };
 
   scoped_ptr<SpdyFrame> resp(ConstructSpdyPostSynReply(NULL, 0));
   scoped_ptr<SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*resp),
@@ skipping 15 matching lines @@
 TEST_P(SpdyNetworkTransactionSpdy2Test, PostWithEarlySynReply) {
   static const char upload[] = { "hello!" };
   ScopedVector<UploadElementReader> element_readers;
   element_readers.push_back(
       new UploadBytesElementReader(upload, sizeof(upload)));
   UploadDataStream stream(&element_readers, 0);
 
   // Setup the request
   HttpRequestInfo request;
   request.method = "POST";
-  request.url = GURL("http://www.google.com/");
+  request.url = GURL(kStreamUrl);
   request.upload_data_stream = &stream;
 
   scoped_ptr<SpdyFrame> stream_reply(ConstructSpdyPostSynReply(NULL, 0));
   scoped_ptr<SpdyFrame> stream_body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*stream_reply, 1),
     MockRead(ASYNC, 0, 3)  // EOF
   };
 
-  scoped_ptr<SpdyFrame> req(ConstructSpdyPost(kUploadDataSize, NULL, 0));
+  scoped_ptr<SpdyFrame> req(
+      ConstructSpdyPost(kStreamUrl, kUploadDataSize, NULL, 0));
   scoped_ptr<SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
     CreateMockWrite(*req, 0),
     CreateMockWrite(*body, 2),
   };
 
   DeterministicSocketData data(reads, arraysize(reads),
                                writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreatePostRequest(),
                                      BoundNetLog(), GetParam(), NULL);
@@ skipping 264 matching lines @@
 }
 
 // Verify that the client can correctly deal with the user callback attempting
 // to start another transaction on a session that is closing down. See
 // http://crbug.com/47455
 TEST_P(SpdyNetworkTransactionSpdy2Test, StartTransactionOnReadCallback) {
   scoped_ptr<SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   MockWrite writes[] = { CreateMockWrite(*req) };
   MockWrite writes2[] = { CreateMockWrite(*req) };
 
-  // The indicated length of this packet is longer than its actual length. When
-  // the session receives an empty packet after this one, it shuts down the
+  // The indicated length of this frame is longer than its actual length. When
+  // the session receives an empty frame after this one, it shuts down the
   // session, and calls the read callback with the incomplete data.
   const uint8 kGetBodyFrame2[] = {
     0x00, 0x00, 0x00, 0x01,
     0x01, 0x00, 0x00, 0x07,
     'h', 'e', 'l', 'l', 'o', '!',
   };
 
   scoped_ptr<SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead reads[] = {
     CreateMockRead(*resp, 2),
@@ skipping 117 matching lines @@
     "http",
     "url",
     "/index.php",
     "user-agent",
     "",
     "version",
     "HTTP/1.1"
   };
 
   // Setup writes/reads to www.google.com
-  scoped_ptr<SpdyFrame> req(ConstructSpdyPacket(
+  scoped_ptr<SpdyFrame> req(ConstructSpdyFrame(
       kSynStartHeader, kExtraHeaders, arraysize(kExtraHeaders) / 2,
       kStandardGetHeaders, arraysize(kStandardGetHeaders) / 2));
-  scoped_ptr<SpdyFrame> req2(ConstructSpdyPacket(
+  scoped_ptr<SpdyFrame> req2(ConstructSpdyFrame(
       kSynStartHeader, kExtraHeaders, arraysize(kExtraHeaders) / 2,
       kStandardGetHeaders2, arraysize(kStandardGetHeaders2) / 2));
   scoped_ptr<SpdyFrame> resp(ConstructSpdyGetSynReplyRedirect(1));
   MockWrite writes[] = {
     CreateMockWrite(*req, 1),
   };
   MockRead reads[] = {
     CreateMockRead(*resp, 2),
     MockRead(ASYNC, 0, 0, 3)  // EOF
   };
@@ skipping 189 matching lines @@
     "url",
     "/",
     "user-agent",
     "",
     "version",
     "HTTP/1.1"
   };
 
   // Setup writes/reads to www.google.com
   scoped_ptr<SpdyFrame> req(
-      ConstructSpdyPacket(kSynStartHeader,
-                          kExtraHeaders,
-                          arraysize(kExtraHeaders) / 2,
-                          kStandardGetHeaders,
-                          arraysize(kStandardGetHeaders) / 2));
+      ConstructSpdyFrame(kSynStartHeader,
+                         kExtraHeaders,
+                         arraysize(kExtraHeaders) / 2,
+                         kStandardGetHeaders,
+                         arraysize(kStandardGetHeaders) / 2));
   scoped_ptr<SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> rep(
       ConstructSpdyPush(NULL,
                         0,
                         2,
                         1,
                         "http://www.google.com/foo.dat",
                         "301 Moved Permanently",
                         "http://www.foo.com/index.php"));
   scoped_ptr<SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
@@ skipping 19 matching lines @@
     "scheme",
     "http",
     "url",
     "/index.php",
     "user-agent",
     "",
     "version",
     "HTTP/1.1"
   };
   scoped_ptr<SpdyFrame> req2(
-      ConstructSpdyPacket(kSynStartHeader,
-                          kExtraHeaders,
-                          arraysize(kExtraHeaders) / 2,
-                          kStandardGetHeaders2,
-                          arraysize(kStandardGetHeaders2) / 2));
+      ConstructSpdyFrame(kSynStartHeader,
+                         kExtraHeaders,
+                         arraysize(kExtraHeaders) / 2,
+                         kStandardGetHeaders2,
+                         arraysize(kStandardGetHeaders2) / 2));
   scoped_ptr<SpdyFrame> resp2(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> body2(ConstructSpdyBodyFrame(1, true));
   MockWrite writes2[] = {
     CreateMockWrite(*req2, 1),
   };
   MockRead reads2[] = {
     CreateMockRead(*resp2, 2),
     CreateMockRead(*body2, 3),
     MockRead(ASYNC, 0, 0, 5)  // EOF
   };
@@ skipping 793 matching lines @@
       ConstructSpdyGet(test_cases[i].extra_headers[0],
                        test_cases[i].num_headers[0],
                        false, 1, LOWEST));
 
     MockWrite writes[] = {
       CreateMockWrite(*frame_req),
     };
 
     // Construct the reply.
     scoped_ptr<SpdyFrame> frame_reply(
-      ConstructSpdyPacket(*test_cases[i].syn_reply,
+      ConstructSpdyFrame(*test_cases[i].syn_reply,
                           test_cases[i].extra_headers[1],
                           test_cases[i].num_headers[1],
                           NULL,
                           0));
 
     scoped_ptr<SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
     MockRead reads[] = {
       CreateMockRead(*frame_reply),
       CreateMockRead(*body),
       MockRead(ASYNC, 0, 0)  // EOF
@@ skipping 95 matching lines @@
   };
 
   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(
-        ConstructSpdyPacket(kSynStartHeader,
-                            NULL, 0,
-                            test_cases[i].headers,
-                            test_cases[i].num_headers));
+        ConstructSpdyFrame(kSynStartHeader,
+                           NULL, 0,
+                           test_cases[i].headers,
+                           test_cases[i].num_headers));
     scoped_ptr<SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
     MockRead reads[] = {
       CreateMockRead(*resp),
       CreateMockRead(*body),
       MockRead(ASYNC, 0, 0)  // EOF
     };
 
     DelayedSocketData data(1, reads, arraysize(reads),
                            writes, arraysize(writes));
     NormalSpdyTransactionHelper helper(CreateGetRequest(),
@@ skipping 677 matching lines @@
   SpdySessionPool* spdy_session_pool = helper.session()->spdy_session_pool();
   EXPECT_TRUE(spdy_session_pool->http_server_properties()->GetSpdySettings(
       host_port_pair).empty());
 
   // Construct the request.
   scoped_ptr<SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   MockWrite writes[] = { CreateMockWrite(*req) };
 
   // Construct the reply.
   scoped_ptr<SpdyFrame> reply(
-    ConstructSpdyPacket(kSynReplyInfo,
-                        kExtraHeaders,
-                        arraysize(kExtraHeaders) / 2,
-                        NULL,
-                        0));
+    ConstructSpdyFrame(kSynReplyInfo,
+                       kExtraHeaders,
+                       arraysize(kExtraHeaders) / 2,
+                       NULL,
+                       0));
 
   const SpdySettingsIds kSampleId1 = SETTINGS_UPLOAD_BANDWIDTH;
   unsigned int kSampleValue1 = 0x0a0a0a0a;
   const SpdySettingsIds kSampleId2 = SETTINGS_DOWNLOAD_BANDWIDTH;
   unsigned int kSampleValue2 = 0x0b0b0b0b;
   const SpdySettingsIds kSampleId3 = SETTINGS_ROUND_TRIP_TIME;
   unsigned int kSampleValue3 = 0x0c0c0c0c;
   scoped_ptr<SpdyFrame> settings_frame;
   {
     // Construct the SETTINGS frame.
@@ skipping 113 matching lines @@
   // Construct the request.
   scoped_ptr<SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
 
   MockWrite writes[] = {
     CreateMockWrite(*settings_frame),
     CreateMockWrite(*req),
   };
 
   // Construct the reply.
   scoped_ptr<SpdyFrame> reply(
-    ConstructSpdyPacket(kSynReplyInfo,
-                        kExtraHeaders,
-                        arraysize(kExtraHeaders) / 2,
-                        NULL,
-                        0));
+    ConstructSpdyFrame(kSynReplyInfo,
+                       kExtraHeaders,
+                       arraysize(kExtraHeaders) / 2,
+                       NULL,
+                       0));
 
   scoped_ptr<SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*reply),
     CreateMockRead(*body),
     MockRead(ASYNC, 0, 0)  // EOF
   };
 
   DelayedSocketData data(2, reads, arraysize(reads),
                          writes, arraysize(writes));
@@ skipping 1491 matching lines @@
   // And now we can allow everything else to run to completion.
   data.SetStop(10);
   data.Run();
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_EQ(OK, callback3.WaitForResult());
 
   helper.VerifyDataConsumed();
 }
 
 }  // namespace net