Cleaning up SPDY unit tests

net/spdy/spdy_network_transaction_unittest.cc

Index: net/spdy/spdy_network_transaction_unittest.cc
diff --git a/net/spdy/spdy_network_transaction_unittest.cc b/net/spdy/spdy_network_transaction_unittest.cc
index c6e1cb072d3274252e637d0b21dfe543201291de..15323c537905d48da0f6ee0879684b283f5c760e 100644
--- a/net/spdy/spdy_network_transaction_unittest.cc
+++ b/net/spdy/spdy_network_transaction_unittest.cc
@@ -28,21 +28,6 @@
 
 namespace net {
 
-// NOTE: In GCC, on a Mac, this can't be in an anonymous namespace!
-// This struct holds information used to construct spdy control and data frames.
-struct SpdyHeaderInfo {
-  int kind;
-  spdy::SpdyStreamId id;
-  spdy::SpdyStreamId assoc_id;
-  int priority;
-  spdy::SpdyControlFlags control_flags;
-  bool compressed;
-  int status;
-  const char* data;
-  uint32 data_length;
-  spdy::SpdyDataFlags data_flags;
-};
-
 namespace {
 
 // Helper to manage the lifetimes of the dependencies for a
@@ -93,322 +78,6 @@ HttpNetworkSession* CreateSession(SessionDependencies* session_deps) {
                                 NULL);
 }
 
-// Chop a frame into an array of MockWrites.
-// |data| is the frame to chop.
-// |length| is the length of the frame to chop.
-// |num_chunks| is the number of chunks to create.
-MockWrite* ChopFrame(const char* data, int length, int num_chunks) {
-  MockWrite* chunks = new MockWrite[num_chunks];
-  int chunk_size = length / num_chunks;
-  for (int index = 0; index < num_chunks; index++) {
-    const char* ptr = data + (index * chunk_size);
-    if (index == num_chunks - 1)
-      chunk_size += length % chunk_size;  // The last chunk takes the remainder.
-    chunks[index] = MockWrite(true, ptr, chunk_size);
-  }
-  return chunks;
-}
-
-// ----------------------------------------------------------------------------
-
-// Adds headers and values to a map.
-// |extra_headers| is an array of { name, value } pairs, arranged as strings
-// where the even entries are the header names, and the odd entries are the
-// header values.
-// |headers| gets filled in from |extra_headers|.
-void AppendHeadersToSpdyFrame(const char* const extra_headers[],
-                              int extra_header_count,
-                              spdy::SpdyHeaderBlock* headers) {
-  std::string this_header;
-  std::string this_value;
-
-  if (!extra_header_count)
-    return;
-
-  // Sanity check: Non-NULL header list.
-  DCHECK(NULL != extra_headers) << "NULL header value pair list";
-  // Sanity check: Non-NULL header map.
-  DCHECK(NULL != headers) << "NULL header map";
-  // Copy in the headers.
-  for (int i = 0; i < extra_header_count; i++) {
-    // Sanity check: Non-empty header.
-    DCHECK_NE('\0', *extra_headers[i * 2]) << "Empty header value pair";
-    this_header = extra_headers[i * 2];
-    std::string::size_type header_len = this_header.length();
-    if (!header_len)
-      continue;
-    this_value = extra_headers[1 + (i * 2)];
-    std::string new_value;
-    if (headers->find(this_header) != headers->end()) {
-      // More than one entry in the header.
-      // Don't add the header again, just the append to the value,
-      // separated by a NULL character.
-
-      // Adjust the value.
-      new_value = (*headers)[this_header];
-      // Put in a NULL separator.
-      new_value.append(1, '\0');
-      // Append the new value.
-      new_value += this_value;
-    } else {
-      // Not a duplicate, just write the value.
-      new_value = this_value;
-    }
-    (*headers)[this_header] = new_value;
-  }
-}
-
-// Writes |str| of the given |len| to the buffer pointed to by |buffer_handle|.
-// Uses a template so buffer_handle can be a char* or an unsigned char*.
-// Updates the |*buffer_handle| pointer by |len|
-// Returns the number of bytes written into *|buffer_handle|
-template<class T>
-int AppendToBuffer(const void* str,
-                   int len,
-                   T** buffer_handle,
-                   int* buffer_len_remaining) {
-  if (len <= 0)
-    return 0;
-  DCHECK(NULL != buffer_handle) << "NULL buffer handle";
-  DCHECK(NULL != *buffer_handle) << "NULL pointer";
-  DCHECK(NULL != buffer_len_remaining)
-      << "NULL buffer remainder length pointer";
-  DCHECK_GE(*buffer_len_remaining, len) << "Insufficient buffer size";
-  memcpy(*buffer_handle, str, len);
-  *buffer_handle += len;
-  *buffer_len_remaining -= len;
-  return len;
-}
-
-// Writes |val| to a location of size |len|, in big-endian format.
-// in the buffer pointed to by |buffer_handle|.
-// Updates the |*buffer_handle| pointer by |len|
-// Returns the number of bytes written
-int AppendToBuffer(int val,
-                   int len,
-                   unsigned char** buffer_handle,
-                   int* buffer_len_remaining) {
-  if (len <= 0)
-    return 0;
-  DCHECK((size_t) len <= sizeof(len)) << "Data length too long for data type";
-  DCHECK(NULL != buffer_handle) << "NULL buffer handle";
-  DCHECK(NULL != *buffer_handle) << "NULL pointer";
-  DCHECK(NULL != buffer_len_remaining)
-      << "NULL buffer remainder length pointer";
-  DCHECK_GE(*buffer_len_remaining, len) << "Insufficient buffer size";
-  for (int i = 0; i < len; i++) {
-    int shift = (8 * (len - (i + 1)));
-    unsigned char val_chunk = (val >> shift) & 0x0FF;
-    *(*buffer_handle)++ = val_chunk;
-    *buffer_len_remaining += 1;
-  }
-  return len;
-}
-
-// Construct a SPDY packet.
-// |head| is the start of the packet, up to but not including
-// the header value pairs.
-// |extra_headers| are the extra header-value pairs, which typically
-// will vary the most between calls.
-// |tail| is any (relatively constant) header-value pairs to add.
-// |buffer| is the buffer we're filling in.
-// Returns a SpdFrame.
-spdy::SpdyFrame* ConstructSpdyPacket(const SpdyHeaderInfo* header_info,
-                                     const char* const extra_headers[],
-                                     int extra_header_count,
-                                     const char* const tail[],
-                                     int tail_header_count) {
-  spdy::SpdyFramer framer;
-  spdy::SpdyHeaderBlock headers;
-  // Copy in the extra headers to our map.
-  AppendHeadersToSpdyFrame(extra_headers, extra_header_count, &headers);
-  // Copy in the tail headers to our map.
-  if (tail && tail_header_count)
-    AppendHeadersToSpdyFrame(tail, tail_header_count, &headers);
-  spdy::SpdyFrame* frame = NULL;
-  switch (header_info->kind) {
-    case spdy::SYN_STREAM:
-      frame = framer.CreateSynStream(header_info->id, header_info->assoc_id,
-                                     header_info->priority,
-                                     header_info->control_flags,
-                                     header_info->compressed, &headers);
-      break;
-    case spdy::SYN_REPLY:
-      frame = framer.CreateSynReply(header_info->id, header_info->control_flags,
-                                    header_info->compressed, &headers);
-      break;
-    case spdy::RST_STREAM:
-      frame = framer.CreateRstStream(header_info->id, header_info->status);
-      break;
-    default:
-      frame = framer.CreateDataFrame(header_info->id, header_info->data,
-                                     header_info->data_length,
-                                     header_info->data_flags);
-      break;
-  }
-  return frame;
-}
-
-// Construct an expected SPDY reply string.
-// |extra_headers| are the extra header-value pairs, which typically
-// will vary the most between calls.
-// |buffer| is the buffer we're filling in.
-// Returns the number of bytes written into |buffer|.
-int ConstructSpdyReply(const char* const extra_headers[],
-                       int extra_header_count,
-                       char* buffer,
-                       int buffer_length) {
-  int packet_size = 0;
-  int header_count = 0;
-  char* buffer_write = buffer;
-  int buffer_left = buffer_length;
-  spdy::SpdyHeaderBlock headers;
-  if (!buffer || !buffer_length)
-    return 0;
-  // Copy in the extra headers.
-  AppendHeadersToSpdyFrame(extra_headers, extra_header_count, &headers);
-  header_count = headers.size();
-  // The iterator gets us the list of header/value pairs in sorted order.
-  spdy::SpdyHeaderBlock::iterator next = headers.begin();
-  spdy::SpdyHeaderBlock::iterator last = headers.end();
-  for ( ; next != last; ++next) {
-    // Write the header.
-    int value_len, current_len, offset;
-    const char* header_string = next->first.c_str();
-    packet_size += AppendToBuffer(header_string,
-                                  next->first.length(),
-                                  &buffer_write,
-                                  &buffer_left);
-    packet_size += AppendToBuffer(": ",
-                                  strlen(": "),
-                                  &buffer_write,
-                                  &buffer_left);
-    // Write the value(s).
-    const char* value_string = next->second.c_str();
-    // Check if it's split among two or more values.
-    value_len = next->second.length();
-    current_len = strlen(value_string);
-    offset = 0;
-    // Handle the first N-1 values.
-    while (current_len < value_len) {
-      // Finish this line -- write the current value.
-      packet_size += AppendToBuffer(value_string + offset,
-                                    current_len - offset,
-                                    &buffer_write,
-                                    &buffer_left);
-      packet_size += AppendToBuffer("\n",
-                                    strlen("\n"),
-                                    &buffer_write,
-                                    &buffer_left);
-      // Advance to next value.
-      offset = current_len + 1;
-      current_len += 1 + strlen(value_string + offset);
-      // Start another line -- add the header again.
-      packet_size += AppendToBuffer(header_string,
-                                    next->first.length(),
-                                    &buffer_write,
-                                    &buffer_left);
-      packet_size += AppendToBuffer(": ",
-                                    strlen(": "),
-                                    &buffer_write,
-                                    &buffer_left);
-    }
-    EXPECT_EQ(value_len, current_len);
-    // Copy the last (or only) value.
-    packet_size += AppendToBuffer(value_string + offset,
-                                  value_len - offset,
-                                  &buffer_write,
-                                  &buffer_left);
-    packet_size += AppendToBuffer("\n",
-                                  strlen("\n"),
-                                  &buffer_write,
-                                  &buffer_left);
-  }
-  return packet_size;
-}
-
-// Construct an expected SPDY SETTINGS frame.
-// |settings| are the settings to set.
-// Returns the constructed frame.  The caller takes ownership of the frame.
-spdy::SpdyFrame* ConstructSpdySettings(spdy::SpdySettings settings) {
-  spdy::SpdyFramer framer;
-  return framer.CreateSettings(settings);
-}
-
-// Construct a single SPDY header entry, for validation.
-// |extra_headers| are the extra header-value pairs.
-// |buffer| is the buffer we're filling in.
-// |index| is the index of the header we want.
-// Returns the number of bytes written into |buffer|.
-int ConstructSpdyHeader(const char* const extra_headers[],
-                        int extra_header_count,
-                        char* buffer,
-                        int buffer_length,
-                        int index) {
-  const char* this_header = NULL;
-  const char* this_value = NULL;
-  if (!buffer || !buffer_length)
-    return 0;
-  *buffer = '\0';
-  // Sanity check: Non-empty header list.
-  DCHECK(NULL != extra_headers) << "NULL extra headers pointer";
-  // Sanity check: Index out of range.
-  DCHECK((index >= 0) && (index < extra_header_count))
-      << "Index " << index
-      << " out of range [0, " << extra_header_count << ")";
-  this_header = extra_headers[index * 2];
-  // Sanity check: Non-empty header.
-  if (!*this_header)
-    return 0;
-  std::string::size_type header_len = strlen(this_header);
-  if (!header_len)
-    return 0;
-  this_value = extra_headers[1 + (index * 2)];
-  // Sanity check: Non-empty value.
-  if (!*this_value)
-    this_value = "";
-  int n = base::snprintf(buffer,
-                         buffer_length,
-                         "%s: %s\r\n",
-                         this_header,
-                         this_value);
-  return n;
-}
-
-// Constructs a standard SPDY GET packet.
-// |extra_headers| are the extra header-value pairs, which typically
-// will vary the most between calls.
-// Returns a SpdFrame.
-spdy::SpdyFrame* ConstructSpdyGet(const char* const extra_headers[],
-                                  int extra_header_count) {
-  SpdyHeaderInfo SynStartHeader = {
-    spdy::SYN_STREAM,             // Kind = Syn
-    1,                            // Stream ID
-    0,                            // Associated stream ID
-    3,                            // Priority
-    spdy::CONTROL_FLAG_FIN,       // Control Flags
-    false,                        // Compressed
-    200,                          // Status
-    NULL,                         // Data
-    0,                            // Length
-    spdy::DATA_FLAG_NONE          // Data Flags
-  };
-  static const char* const kStandardGetHeaders[] = {
-    "method",
-    "GET",
-    "url",
-    "http://www.google.com/",
-    "version",
-    "HTTP/1.1"
-  };
-  return ConstructSpdyPacket(
-      &SynStartHeader,
-      extra_headers,
-      extra_header_count,
-      kStandardGetHeaders,
-      arraysize(kStandardGetHeaders) / 2);
-}
-
 }  // namespace
 
 class SpdyNetworkTransactionTest : public PlatformTest {
@@ -524,14 +193,13 @@ TEST_F(SpdyNetworkTransactionTest, Constructor) {
 }
 
 TEST_F(SpdyNetworkTransactionTest, Get) {
-  MockWrite writes[] = {
-    MockWrite(true, reinterpret_cast<const char*>(kGetSyn),
-              arraysize(kGetSyn)),
-  };
+  // Construct the request.
+  scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0));
+  MockWrite writes[] = { CreateMockWrite(req.get()) };
 
+  scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0));
   MockRead reads[] = {
-    MockRead(true, reinterpret_cast<const char*>(kGetSynReply),
-             arraysize(kGetSynReply)),
+    CreateMockRead(resp.get()),
     MockRead(true, reinterpret_cast<const char*>(kGetBodyFrame),
              arraysize(kGetBodyFrame)),
     MockRead(true, 0, 0)  // EOF
@@ -591,7 +259,7 @@ TEST_F(SpdyNetworkTransactionTest, EmptyPost) {
     0x01, 0x00, 0x00, 0x4a,                                      // flags, len
     0x00, 0x00, 0x00, 0x01,                                      // stream id
     0x00, 0x00, 0x00, 0x00,                                      // associated
-    0xc0, 0x00, 0x00, 0x03,                                      // 4 headers
+    0xc0, 0x00, 0x00, 0x03,                                      // 3 headers
     0x00, 0x06, 'm', 'e', 't', 'h', 'o', 'd',
     0x00, 0x04, 'P', 'O', 'S', 'T',
     0x00, 0x03, 'u', 'r', 'l',
@@ -691,16 +359,13 @@ TEST_F(SpdyNetworkTransactionTest, ResponseWithTwoSynReplies) {
   // We disable SSL for this test.
   SpdySession::SetSSLMode(false);
 
-  MockWrite writes[] = {
-    MockWrite(true, reinterpret_cast<const char*>(kGetSyn),
-              arraysize(kGetSyn)),
-  };
+  scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0));
+  MockWrite writes[] = { CreateMockWrite(req.get()) };
 
+  scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0));
   MockRead reads[] = {
-    MockRead(true, reinterpret_cast<const char*>(kGetSynReply),
-             arraysize(kGetSynReply)),
-    MockRead(true, reinterpret_cast<const char*>(kGetSynReply),
-             arraysize(kGetSynReply)),
+    CreateMockRead(resp.get()),
+    CreateMockRead(resp.get()),
     MockRead(true, reinterpret_cast<const char*>(kGetBodyFrame),
              arraysize(kGetBodyFrame)),
     MockRead(true, 0, 0)  // EOF
@@ -733,15 +398,16 @@ TEST_F(SpdyNetworkTransactionTest, ResponseWithTwoSynReplies) {
 }
 
 TEST_F(SpdyNetworkTransactionTest, CancelledTransaction) {
+  // Construct the request.
+  scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0));
   MockWrite writes[] = {
-    MockWrite(true, reinterpret_cast<const char*>(kGetSyn),
-              arraysize(kGetSyn)),
+    CreateMockWrite(req.get()),
     MockRead(true, 0, 0)  // EOF
   };
 
+  scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0));
   MockRead reads[] = {
-    MockRead(true, reinterpret_cast<const char*>(kGetSynReply),
-             arraysize(kGetSynReply)),
+    CreateMockRead(resp.get()),
     // This following read isn't used by the test, except during the
     // RunAllPending() call at the end since the SpdySession survives the
     // SpdyNetworkTransaction and still tries to continue Read()'ing.  Any
@@ -791,14 +457,12 @@ class DeleteSessionCallback : public CallbackRunner< Tuple1<int> > {
 // transaction. Failures will usually be valgrind errors. See
 // http://crbug.com/46925
 TEST_F(SpdyNetworkTransactionTest, DeleteSessionOnReadCallback) {
-  MockWrite writes[] = {
-    MockWrite(true, reinterpret_cast<const char*>(kGetSyn),
-              arraysize(kGetSyn), 1),
-  };
+  scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0));
+  MockWrite writes[] = { CreateMockWrite(req.get()) };
 
+  scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0));
   MockRead reads[] = {
-    MockRead(true, reinterpret_cast<const char*>(kGetSynReply),
-             arraysize(kGetSynReply), 2),
+    CreateMockRead(resp.get(), 2),
     MockRead(true, ERR_IO_PENDING, 3),  // Force a pause
     MockRead(true, reinterpret_cast<const char*>(kGetBodyFrame),
              arraysize(kGetBodyFrame), 4),
@@ -921,10 +585,8 @@ TEST_F(SpdyNetworkTransactionTest, SynReplyHeaders) {
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
-    MockWrite writes[] = {
-      MockWrite(true, reinterpret_cast<const char*>(kGetSyn),
-                arraysize(kGetSyn)),
-    };
+    scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0));
+    MockWrite writes[] = { CreateMockWrite(req.get()) };
 
     MockRead reads[] = {
       MockRead(true, reinterpret_cast<const char*>(test_cases[i].syn_reply),
@@ -965,10 +627,10 @@ TEST_F(SpdyNetworkTransactionTest, SynReplyHeadersVary) {
     spdy::SYN_REPLY,                              // Syn Reply
     1,                                            // Stream ID
     0,                                            // Associated Stream ID
-    3,                                            // Priority
+    SPDY_PRIORITY_LOWEST,                         // Priority
     spdy::CONTROL_FLAG_NONE,                      // Control Flags
     false,                                        // Compressed
-    200,                                          // Status
+    spdy::INVALID,                                // Status
     NULL,                                         // Data
     0,                                            // Data Length
     spdy::DATA_FLAG_NONE                          // Data Flags
@@ -1051,10 +713,7 @@ TEST_F(SpdyNetworkTransactionTest, SynReplyHeadersVary) {
                        test_cases[i].num_headers[0]));
 
     MockWrite writes[] = {
-      MockWrite(
-          true,
-          frame_req->data(),
-          frame_req->length() + spdy::SpdyFrame::size()),
+      CreateMockWrite(frame_req.get()),
     };
 
     // Construct the reply.
@@ -1066,9 +725,7 @@ TEST_F(SpdyNetworkTransactionTest, SynReplyHeadersVary) {
                           0));
 
     MockRead reads[] = {
-      MockRead(true,
-               frame_reply->data(),
-               frame_reply->length() + spdy::SpdyFrame::size()),
+      CreateMockRead(frame_reply.get()),
       MockRead(true,
                reinterpret_cast<const char*>(kGetBodyFrame),
                arraysize(kGetBodyFrame)),
@@ -1121,10 +778,10 @@ TEST_F(SpdyNetworkTransactionTest, SynReplyHeadersVary) {
 
     // Construct the expected header reply string.
     char reply_buffer[256] = "";
-    ConstructSpdyReply(test_cases[i].extra_headers[1],
-                       test_cases[i].num_headers[1],
-                       reply_buffer,
-                       256);
+    ConstructSpdyReplyString(test_cases[i].extra_headers[1],
+                             test_cases[i].num_headers[1],
+                             reply_buffer,
+                             256);
 
     EXPECT_EQ(std::string(reply_buffer), lines) << i;
   }
@@ -1166,9 +823,9 @@ TEST_F(SpdyNetworkTransactionTest, InvalidSynReply) {
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
+    scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0));
     MockWrite writes[] = {
-      MockWrite(true, reinterpret_cast<const char*>(kGetSyn),
-                arraysize(kGetSyn)),
+      CreateMockWrite(req.get()),
       MockWrite(true, 0, 0)  // EOF
     };
 
@@ -1211,9 +868,9 @@ TEST_F(SpdyNetworkTransactionTest, CorruptFrameSessionError) {
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
+    scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0));
     MockWrite writes[] = {
-      MockWrite(true, reinterpret_cast<const char*>(kGetSyn),
-                arraysize(kGetSyn)),
+      CreateMockWrite(req.get()),
       MockWrite(true, 0, 0)  // EOF
     };
 
@@ -1398,10 +1055,8 @@ TEST_F(SpdyNetworkTransactionTest, ServerPush) {
   const char syn_body_data2[] = "hello my darling hello my baby";
   const char* syn_body_data = NULL;
 
-  MockWrite writes[] = {
-    MockWrite(true, reinterpret_cast<const char*>(kGetSyn),
-              arraysize(kGetSyn)),
-  };
+  scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0));
+  MockWrite writes[] = { CreateMockWrite(req.get()) };
 
   // This array is for request before and after push is received.  The push
   // body is only one 'packet', to allow the initial transaction to read all
@@ -1552,17 +1207,18 @@ TEST_F(SpdyNetworkTransactionTest, ServerPush) {
 
 // Test that we shutdown correctly on write errors.
 TEST_F(SpdyNetworkTransactionTest, WriteError) {
+  scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0));
   MockWrite writes[] = {
     // We'll write 10 bytes successfully
-    MockWrite(true, reinterpret_cast<const char*>(kGetSyn), 10),
+    MockWrite(true, req->data(), 10),
     // Followed by ERROR!
     MockWrite(true, ERR_FAILED),
     MockWrite(true, 0, 0)  // EOF
   };
 
+  scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0));
   MockRead reads[] = {
-    MockRead(true, reinterpret_cast<const char*>(kGetSynReply),
-             arraysize(kGetSynReply)),
+    CreateMockRead(resp.get(), 2),
     MockRead(true, reinterpret_cast<const char*>(kGetBodyFrame),
              arraysize(kGetBodyFrame)),
     MockRead(true, 0, 0)  // EOF
@@ -1581,13 +1237,13 @@ TEST_F(SpdyNetworkTransactionTest, WriteError) {
 // Test that partial writes work.
 TEST_F(SpdyNetworkTransactionTest, PartialWrite) {
   // Chop the SYN_STREAM frame into 5 chunks.
+  scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0));
   const int kChunks = 5;
-  scoped_array<MockWrite> writes(ChopFrame(
-      reinterpret_cast<const char*>(kGetSyn), arraysize(kGetSyn), kChunks));
+  scoped_array<MockWrite> writes(ChopFrame(req.get(), kChunks));
 
+  scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0));
   MockRead reads[] = {
-    MockRead(true, reinterpret_cast<const char*>(kGetSynReply),
-             arraysize(kGetSynReply)),
+    CreateMockRead(resp.get()),
     MockRead(true, reinterpret_cast<const char*>(kGetBodyFrame),
              arraysize(kGetBodyFrame)),
     MockRead(true, 0, 0)  // EOF
@@ -1613,15 +1269,15 @@ TEST_F(SpdyNetworkTransactionTest, ConnectFailure) {
   };
 
   for (size_t index = 0; index < arraysize(connects); ++index) {
+    scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0));
     MockWrite writes[] = {
-      MockWrite(true, reinterpret_cast<const char*>(kGetSyn),
-                arraysize(kGetSyn)),
+      CreateMockWrite(req.get()),
       MockWrite(true, 0, 0)  // EOF
     };
 
+    scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0));
     MockRead reads[] = {
-      MockRead(true, reinterpret_cast<const char*>(kGetSynReply),
-               arraysize(kGetSynReply)),
+      CreateMockRead(resp.get()),
       MockRead(true, reinterpret_cast<const char*>(kGetBodyFrame),
                arraysize(kGetBodyFrame)),
       MockRead(true, 0, 0)  // EOF
@@ -1646,9 +1302,9 @@ TEST_F(SpdyNetworkTransactionTest, DecompressFailureOnSynReply) {
     MockWrite(true, 0, 0)  // EOF
   };
 
+  scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0));
   MockRead reads[] = {
-    MockRead(true, reinterpret_cast<const char*>(kGetSynReply),
-             arraysize(kGetSynReply)),
+    CreateMockRead(resp.get()),
     MockRead(true, reinterpret_cast<const char*>(kGetBodyFrame),
              arraysize(kGetBodyFrame)),
     MockRead(true, 0, 0)  // EOF
@@ -1671,14 +1327,12 @@ TEST_F(SpdyNetworkTransactionTest, DecompressFailureOnSynReply) {
 
 // Test that the NetLog contains good data for a simple GET request.
 TEST_F(SpdyNetworkTransactionTest, NetLog) {
-  MockWrite writes[] = {
-    MockWrite(true, reinterpret_cast<const char*>(kGetSyn),
-              arraysize(kGetSyn)),
-  };
+  scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0));
+  MockWrite writes[] = { CreateMockWrite(req.get()) };
 
+  scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0));
   MockRead reads[] = {
-    MockRead(true, reinterpret_cast<const char*>(kGetSynReply),
-             arraysize(kGetSynReply)),
+    CreateMockRead(resp.get()),
     MockRead(true, reinterpret_cast<const char*>(kGetBodyFrame),
              arraysize(kGetBodyFrame)),
     MockRead(true, 0, 0)  // EOF
@@ -1734,10 +1388,8 @@ TEST_F(SpdyNetworkTransactionTest, NetLog) {
 // on the network, but issued a Read for only 5 of those bytes) that the data
 // flow still works correctly.
 TEST_F(SpdyNetworkTransactionTest, BufferFull) {
-  MockWrite writes[] = {
-    MockWrite(true, reinterpret_cast<const char*>(kGetSyn),
-              arraysize(kGetSyn)),
-  };
+  scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0));
+  MockWrite writes[] = { CreateMockWrite(req.get()) };
 
   static const unsigned char kCombinedDataFrames[] = {
     0x00, 0x00, 0x00, 0x01,                                      // header
@@ -1754,9 +1406,9 @@ TEST_F(SpdyNetworkTransactionTest, BufferFull) {
     'd',
   };
 
+  scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0));
   MockRead reads[] = {
-    MockRead(true, reinterpret_cast<const char*>(kGetSynReply),
-             arraysize(kGetSynReply)),
+    CreateMockRead(resp.get()),
     MockRead(true, ERR_IO_PENDING),  // Force a pause
     MockRead(true, reinterpret_cast<const char*>(kCombinedDataFrames),
              arraysize(kCombinedDataFrames)),
@@ -1838,10 +1490,8 @@ TEST_F(SpdyNetworkTransactionTest, BufferFull) {
 // at the same time, ensure that we don't notify a read completion for
 // each data frame individually.
 TEST_F(SpdyNetworkTransactionTest, Buffering) {
-  MockWrite writes[] = {
-    MockWrite(true, reinterpret_cast<const char*>(kGetSyn),
-              arraysize(kGetSyn)),
-  };
+  scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0));
+  MockWrite writes[] = { CreateMockWrite(req.get()) };
 
   // 4 data frames in a single read.
   static const unsigned char kCombinedDataFrames[] = {
@@ -1859,9 +1509,9 @@ TEST_F(SpdyNetworkTransactionTest, Buffering) {
     'm', 'e', 's', 's', 'a', 'g', 'e',
   };
 
+  scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0));
   MockRead reads[] = {
-    MockRead(true, reinterpret_cast<const char*>(kGetSynReply),
-             arraysize(kGetSynReply)),
+    CreateMockRead(resp.get()),
     MockRead(true, ERR_IO_PENDING),  // Force a pause
     MockRead(true, reinterpret_cast<const char*>(kCombinedDataFrames),
              arraysize(kCombinedDataFrames)),
@@ -1942,10 +1592,8 @@ TEST_F(SpdyNetworkTransactionTest, Buffering) {
 
 // Verify the case where we buffer data but read it after it has been buffered.
 TEST_F(SpdyNetworkTransactionTest, BufferedAll) {
-  MockWrite writes[] = {
-    MockWrite(true, reinterpret_cast<const char*>(kGetSyn),
-              arraysize(kGetSyn)),
-  };
+  scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0));
+  MockWrite writes[] = { CreateMockWrite(req.get()) };
 
   // The Syn Reply and all data frames in a single read.
   static const unsigned char kCombinedFrames[] = {
@@ -2051,10 +1699,8 @@ TEST_F(SpdyNetworkTransactionTest, BufferedAll) {
 
 // Verify the case where we buffer data and close the connection.
 TEST_F(SpdyNetworkTransactionTest, BufferedClosed) {
-  MockWrite writes[] = {
-    MockWrite(true, reinterpret_cast<const char*>(kGetSyn),
-              arraysize(kGetSyn)),
-  };
+  scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0));
+  MockWrite writes[] = { CreateMockWrite(req.get()) };
 
   // All data frames in a single read.
   static const unsigned char kCombinedFrames[] = {
@@ -2073,9 +1719,9 @@ TEST_F(SpdyNetworkTransactionTest, BufferedClosed) {
     // NOTE: We didn't FIN the stream.
   };
 
+  scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0));
   MockRead reads[] = {
-    MockRead(true, reinterpret_cast<const char*>(kGetSynReply),
-             arraysize(kGetSynReply)),
+    CreateMockRead(resp.get()),
     MockRead(true, ERR_IO_PENDING),  // Force a wait
     MockRead(true, reinterpret_cast<const char*>(kCombinedFrames),
              arraysize(kCombinedFrames)),
@@ -2153,10 +1799,8 @@ TEST_F(SpdyNetworkTransactionTest, BufferedClosed) {
 
 // Verify the case where we buffer data and cancel the transaction.
 TEST_F(SpdyNetworkTransactionTest, BufferedCancelled) {
-  MockWrite writes[] = {
-    MockWrite(true, reinterpret_cast<const char*>(kGetSyn),
-              arraysize(kGetSyn)),
-  };
+  scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0));
+  MockWrite writes[] = { CreateMockWrite(req.get()) };
 
   static const unsigned char kDataFrame[] = {
     0x00, 0x00, 0x00, 0x01,                                      // header
@@ -2165,9 +1809,9 @@ TEST_F(SpdyNetworkTransactionTest, BufferedCancelled) {
     // NOTE: We didn't FIN the stream.
   };
 
+  scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0));
   MockRead reads[] = {
-    MockRead(true, reinterpret_cast<const char*>(kGetSynReply),
-             arraysize(kGetSynReply)),
+    CreateMockRead(resp.get()),
     MockRead(true, ERR_IO_PENDING),  // Force a wait
     MockRead(true, reinterpret_cast<const char*>(kDataFrame),
              arraysize(kDataFrame)),
@@ -2236,10 +1880,10 @@ TEST_F(SpdyNetworkTransactionTest, SettingsSaved) {
     spdy::SYN_REPLY,                              // Syn Reply
     1,                                            // Stream ID
     0,                                            // Associated Stream ID
-    3,                                            // Priority
+    SPDY_PRIORITY_LOWEST,                         // Priority
     spdy::CONTROL_FLAG_NONE,                      // Control Flags
     false,                                        // Compressed
-    200,                                          // Status
+    spdy::INVALID,                                // Status
     NULL,                                         // Data
     0,                                            // Data Length
     spdy::DATA_FLAG_NONE                          // Data Flags
@@ -2258,10 +1902,7 @@ TEST_F(SpdyNetworkTransactionTest, SettingsSaved) {
 
   // Construct the request.
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0));
-
-  MockWrite writes[] = {
-    MockWrite(true, req->data(), req->length() + spdy::SpdyFrame::size()),
-  };
+  MockWrite writes[] = { CreateMockWrite(req.get()) };
 
   // Construct the reply.
   scoped_ptr<spdy::SpdyFrame> reply(
@@ -2298,11 +1939,10 @@ TEST_F(SpdyNetworkTransactionTest, SettingsSaved) {
   }
 
   MockRead reads[] = {
-    MockRead(true, reply->data(), reply->length() + spdy::SpdyFrame::size()),
+    CreateMockRead(reply.get()),
     MockRead(true, reinterpret_cast<const char*>(kGetBodyFrame),
              arraysize(kGetBodyFrame)),
-    MockRead(true, settings_frame->data(),
-             settings_frame->length() + spdy::SpdyFrame::size()),
+    CreateMockRead(settings_frame.get()),
     MockRead(true, 0, 0)  // EOF
   };
 
@@ -2345,10 +1985,10 @@ TEST_F(SpdyNetworkTransactionTest, SettingsPlayback) {
     spdy::SYN_REPLY,                              // Syn Reply
     1,                                            // Stream ID
     0,                                            // Associated Stream ID
-    3,                                            // Priority
+    SPDY_PRIORITY_LOWEST,                         // Priority
     spdy::CONTROL_FLAG_NONE,                      // Control Flags
     false,                                        // Compressed
-    200,                                          // Status
+    spdy::INVALID,                                // Status
     NULL,                                         // Data
     0,                                            // Data Length
     spdy::DATA_FLAG_NONE                          // Data Flags
@@ -2396,9 +2036,8 @@ TEST_F(SpdyNetworkTransactionTest, SettingsPlayback) {
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0));
 
   MockWrite writes[] = {
-    MockWrite(true, settings_frame->data(),
-              settings_frame->length() + spdy::SpdyFrame::size()),
-    MockWrite(true, req->data(), req->length() + spdy::SpdyFrame::size()),
+    CreateMockWrite(settings_frame.get()),
+    CreateMockWrite(req.get()),
   };
 
   // Construct the reply.
@@ -2410,7 +2049,7 @@ TEST_F(SpdyNetworkTransactionTest, SettingsPlayback) {
                         0));
 
   MockRead reads[] = {
-    MockRead(true, reply->data(), reply->length() + spdy::SpdyFrame::size()),
+    CreateMockRead(reply.get()),
     MockRead(true, reinterpret_cast<const char*>(kGetBodyFrame),
              arraysize(kGetBodyFrame)),
     MockRead(true, 0, 0)  // EOF
@@ -2449,10 +2088,8 @@ TEST_F(SpdyNetworkTransactionTest, SettingsPlayback) {
 }
 
 TEST_F(SpdyNetworkTransactionTest, GoAwayWithActiveStream) {
-  MockWrite writes[] = {
-    MockWrite(true, reinterpret_cast<const char*>(kGetSyn),
-              arraysize(kGetSyn)),
-  };
+  scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0));
+  MockWrite writes[] = { CreateMockWrite(req.get()) };
 
   MockRead reads[] = {
     MockRead(true, reinterpret_cast<const char*>(kGoAway),
@@ -2470,14 +2107,12 @@ TEST_F(SpdyNetworkTransactionTest, GoAwayWithActiveStream) {
 }
 
 TEST_F(SpdyNetworkTransactionTest, CloseWithActiveStream) {
-  MockWrite writes[] = {
-    MockWrite(true, reinterpret_cast<const char*>(kGetSyn),
-              arraysize(kGetSyn)),
-  };
+  scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0));
+  MockWrite writes[] = { CreateMockWrite(req.get()) };
 
+  scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0));
   MockRead reads[] = {
-    MockRead(true, reinterpret_cast<const char*>(kGetSynReply),
-              arraysize(kGetSynReply)),
+    CreateMockRead(resp.get()),
     MockRead(false, 0, 0)  // EOF
   };