Stop using SpdySynStreamIR for SPDY 4.

net/spdy/spdy_test_util_common.cc

 // Copyright (c) 2013 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/spdy/spdy_test_util_common.h"
 
 #include <cstddef>
 
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 921 matching lines @@
     SpdyRstStreamStatus status) const {
   SpdyRstStreamIR rst_ir(stream_id, status, "");
   return CreateFramer(false)->SerializeRstStream(rst_ir);
 }
 
 SpdyFrame* SpdyTestUtil::ConstructSpdyGet(
     const char* const url,
     bool compressed,
     SpdyStreamId stream_id,
     RequestPriority request_priority) const {
-  const SpdyHeaderInfo header_info = {
-    SYN_STREAM,
-    stream_id,
-    0,                   // associated stream ID
-    ConvertRequestPriorityToSpdyPriority(request_priority, spdy_version_),
-    0,                   // credential slot
-    CONTROL_FLAG_FIN,
-    compressed,
-    RST_STREAM_INVALID,  // status
-    NULL,                // data
-    0,                   // length
-    DATA_FLAG_NONE
-  };
-  return ConstructSpdyFrame(header_info, ConstructGetHeaderBlock(url));
+  scoped_ptr<SpdyHeaderBlock> block(ConstructGetHeaderBlock(url));
+  return ConstructSpdySyn(
+      stream_id, *block, request_priority, compressed, true);
 }
 
 SpdyFrame* SpdyTestUtil::ConstructSpdyGet(const char* const extra_headers[],
                                           int extra_header_count,
                                           bool compressed,
                                           int stream_id,
                                           RequestPriority request_priority,
                                           bool direct) const {
-  SpdySynStreamIR syn_stream(stream_id);
-  syn_stream.set_priority(
-      ConvertRequestPriorityToSpdyPriority(request_priority, spdy_version_));
-  syn_stream.set_fin(true);
-  syn_stream.SetHeader(GetMethodKey(), "GET");
-  syn_stream.SetHeader(GetHostKey(), "www.google.com");
-  syn_stream.SetHeader(GetSchemeKey(), "http");
-  syn_stream.SetHeader(GetPathKey(), (is_spdy2() && !direct) ?
-                       "http://www.google.com/" : "/");
-  MaybeAddVersionHeader(&syn_stream);
-  AppendToHeaderBlock(extra_headers, extra_header_count,
-                      syn_stream.mutable_name_value_block());
-  return CreateFramer(compressed)->SerializeFrame(syn_stream);
+  SpdyHeaderBlock block;
+  block[GetMethodKey()] = "GET";
+  block[GetPathKey()] =
+      (is_spdy2() && !direct) ? "http://www.google.com/" : "/";
+  block[GetHostKey()] = "www.google.com";
+  block[GetSchemeKey()] = "http";
+  MaybeAddVersionHeader(&block);
+  AppendToHeaderBlock(extra_headers, extra_header_count, &block);
+  return ConstructSpdySyn(stream_id, block, request_priority, compressed, true);
 }
 
 SpdyFrame* SpdyTestUtil::ConstructSpdyConnect(
     const char* const extra_headers[],
     int extra_header_count,
     int stream_id,
     RequestPriority priority) const {
-  SpdySynStreamIR syn_stream(stream_id);
-  syn_stream.set_priority(
-      ConvertRequestPriorityToSpdyPriority(priority, spdy_version_));
-  syn_stream.SetHeader(GetMethodKey(), "CONNECT");
-  syn_stream.SetHeader(GetPathKey(), "www.google.com:443");
-  syn_stream.SetHeader(GetHostKey(), "www.google.com");
-  MaybeAddVersionHeader(&syn_stream);
-  AppendToHeaderBlock(extra_headers, extra_header_count,
-                      syn_stream.mutable_name_value_block());
-  return CreateFramer(false)->SerializeFrame(syn_stream);
+  SpdyHeaderBlock block;
+  block[GetMethodKey()] = "CONNECT";
+  block[GetPathKey()] = "www.google.com:443";
+  block[GetHostKey()] = "www.google.com";
+  MaybeAddVersionHeader(&block);
+  AppendToHeaderBlock(extra_headers, extra_header_count, &block);
+  return ConstructSpdySyn(stream_id, block, priority, false, false);
 }
 
 SpdyFrame* SpdyTestUtil::ConstructSpdyPush(const char* const extra_headers[],
                                            int extra_header_count,
                                            int stream_id,
                                            int associated_stream_id,
                                            const char* url) {
   if (spdy_version() < SPDY4) {
     SpdySynStreamIR syn_stream(stream_id);
     syn_stream.set_associated_to_stream_id(associated_stream_id);
     syn_stream.SetHeader("hello", "bye");
     syn_stream.SetHeader(GetStatusKey(), "200 OK");
     syn_stream.SetHeader(GetVersionKey(), "HTTP/1.1");
     AddUrlToHeaderBlock(url, syn_stream.mutable_name_value_block());
     AppendToHeaderBlock(extra_headers,
                         extra_header_count,
                         syn_stream.mutable_name_value_block());
     return CreateFramer(false)->SerializeFrame(syn_stream);
   } else {
     SpdyPushPromiseIR push_promise(associated_stream_id, stream_id);
     AddUrlToHeaderBlock(url, push_promise.mutable_name_value_block());
     scoped_ptr<SpdyFrame> push_promise_frame(
         CreateFramer(false)->SerializeFrame(push_promise));
 
-    // Use SynStreamIR to create HEADERS+PRIORITY. Direct creation breaks
-    // framer.
-    SpdySynStreamIR headers(stream_id);
-    SetPriority(LOWEST, &headers);
+    SpdyHeadersIR headers(stream_id);
     headers.SetHeader("hello", "bye");
     headers.SetHeader(GetStatusKey(), "200 OK");
     AppendToHeaderBlock(
         extra_headers, extra_header_count, headers.mutable_name_value_block());
     scoped_ptr<SpdyFrame> headers_frame(
         CreateFramer(false)->SerializeFrame(headers));
 
     int joint_data_size = push_promise_frame->size() + headers_frame->size();
     scoped_ptr<char[]> data(new char[joint_data_size]);
     const SpdyFrame* frames[2] = {
@@ skipping 24 matching lines @@
     AppendToHeaderBlock(extra_headers,
                         extra_header_count,
                         syn_stream.mutable_name_value_block());
     return CreateFramer(false)->SerializeFrame(syn_stream);
   } else {
     SpdyPushPromiseIR push_promise(associated_stream_id, stream_id);
     AddUrlToHeaderBlock(url, push_promise.mutable_name_value_block());
     scoped_ptr<SpdyFrame> push_promise_frame(
         CreateFramer(false)->SerializeFrame(push_promise));
 
-    // Use SynStreamIR to create HEADERS+PRIORITY. Direct creation breaks
-    // framer.
-    SpdySynStreamIR headers(stream_id);
-    SetPriority(LOWEST, &headers);
+    SpdyHeadersIR headers(stream_id);
     headers.SetHeader("hello", "bye");
     headers.SetHeader(GetStatusKey(), status);
     headers.SetHeader("location", location);
     AppendToHeaderBlock(
         extra_headers, extra_header_count, headers.mutable_name_value_block());
     scoped_ptr<SpdyFrame> headers_frame(
         CreateFramer(false)->SerializeFrame(headers));
 
     int joint_data_size = push_promise_frame->size() + headers_frame->size();
     scoped_ptr<char[]> data(new char[joint_data_size]);
@@ skipping 29 matching lines @@
     const char* const extra_headers[],
     int extra_header_count) {
   SpdyHeadersIR headers(stream_id);
   headers.SetHeader(GetStatusKey(), "200 OK");
   MaybeAddVersionHeader(&headers);
   AppendToHeaderBlock(extra_headers, extra_header_count,
                       headers.mutable_name_value_block());
   return CreateFramer(false)->SerializeFrame(headers);
 }
 
+SpdyFrame* SpdyTestUtil::ConstructSpdySyn(int stream_id,
+                                          const SpdyHeaderBlock& block,
+                                          RequestPriority priority,
+                                          bool compressed,
+                                          bool fin) const {
+  if (protocol_ < kProtoSPDY4) {
+    SpdySynStreamIR syn_stream(stream_id);
+    syn_stream.set_name_value_block(block);
+    syn_stream.set_priority(
+        ConvertRequestPriorityToSpdyPriority(priority, spdy_version()));
+    syn_stream.set_fin(fin);
+    return CreateFramer(compressed)->SerializeFrame(syn_stream);
+  } else {
+    SpdyHeadersIR headers(stream_id);
+    headers.set_name_value_block(block);
+    headers.set_has_priority(true);
+    headers.set_priority(
+        ConvertRequestPriorityToSpdyPriority(priority, spdy_version()));
+    headers.set_fin(fin);
+    return CreateFramer(compressed)->SerializeFrame(headers);
+  }
+}
+
 SpdyFrame* SpdyTestUtil::ConstructSpdyReply(int stream_id,
                                             const SpdyHeaderBlock& headers) {
   if (protocol_ < kProtoSPDY4) {
     SpdySynReplyIR syn_reply(stream_id);
     syn_reply.set_name_value_block(headers);
     return CreateFramer(false)->SerializeFrame(syn_reply);
   } else {
     SpdyHeadersIR reply(stream_id);
     reply.set_name_value_block(headers);
     return CreateFramer(false)->SerializeFrame(reply);
@@ skipping 38 matching lines @@
 
   return ConstructSpdyReply(stream_id, block);
 }
 
 SpdyFrame* SpdyTestUtil::ConstructSpdyPost(const char* url,
                                            SpdyStreamId stream_id,
                                            int64 content_length,
                                            RequestPriority priority,
                                            const char* const extra_headers[],
                                            int extra_header_count) {
-  const SpdyHeaderInfo kSynStartHeader = {
-    SYN_STREAM,
-    stream_id,
-    0,                      // Associated stream ID
-    ConvertRequestPriorityToSpdyPriority(priority, spdy_version_),
-    kSpdyCredentialSlotUnused,
-    CONTROL_FLAG_NONE,
-    false,                  // Compressed
-    RST_STREAM_INVALID,
-    NULL,                   // Data
-    0,                      // Length
-    DATA_FLAG_NONE
-  };
-  return ConstructSpdyFrame(
-      kSynStartHeader, ConstructPostHeaderBlock(url, content_length));
+  scoped_ptr<SpdyHeaderBlock> block(
+      ConstructPostHeaderBlock(url, content_length));
+  AppendToHeaderBlock(extra_headers, extra_header_count, block.get());
+  return ConstructSpdySyn(stream_id, *block, priority, false, false);
 }
 
 SpdyFrame* SpdyTestUtil::ConstructChunkedSpdyPost(
     const char* const extra_headers[],
     int extra_header_count) {
-  SpdySynStreamIR syn_stream(1);
-  syn_stream.SetHeader(GetMethodKey(), "POST");
-  syn_stream.SetHeader(GetPathKey(), "/");
-  syn_stream.SetHeader(GetHostKey(), "www.google.com");
-  syn_stream.SetHeader(GetSchemeKey(), "http");
-  MaybeAddVersionHeader(&syn_stream);
-  SetPriority(LOWEST, &syn_stream);
-  AppendToHeaderBlock(extra_headers, extra_header_count,
-                      syn_stream.mutable_name_value_block());
-  return CreateFramer(false)->SerializeFrame(syn_stream);
+  SpdyHeaderBlock block;
+  block[GetMethodKey()] = "POST";
+  block[GetPathKey()] = "/";
+  block[GetHostKey()] = "www.google.com";
+  block[GetSchemeKey()] = "http";
+  MaybeAddVersionHeader(&block);
+  AppendToHeaderBlock(extra_headers, extra_header_count, &block);
+  return ConstructSpdySyn(1, block, LOWEST, false, false);
 }
 
 SpdyFrame* SpdyTestUtil::ConstructSpdyPostSynReply(
     const char* const extra_headers[],
     int extra_header_count) {
   // TODO(jgraettinger): Remove this method.
   return ConstructSpdyGetSynReply(NULL, 0, 1);
 }
 
 SpdyFrame* SpdyTestUtil::ConstructSpdyBodyFrame(int stream_id, bool fin) {
@@ skipping 107 matching lines @@
   }
 }
 
 void SpdyTestUtil::SetPriority(RequestPriority priority,
                                SpdySynStreamIR* ir) const {
   ir->set_priority(ConvertRequestPriorityToSpdyPriority(
       priority, spdy_version()));
 }
 
 }  // namespace net