Support HTTP/2 drafts 14 and 15 simultaneously.

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 39 matching lines @@
 }
 
 }  // namespace
 
 NextProtoVector SpdyNextProtos() {
   NextProtoVector next_protos;
   next_protos.push_back(kProtoHTTP11);
   next_protos.push_back(kProtoDeprecatedSPDY2);
   next_protos.push_back(kProtoSPDY3);
   next_protos.push_back(kProtoSPDY31);
-  next_protos.push_back(kProtoSPDY4);
+  next_protos.push_back(kProtoSPDY4_14);
+  next_protos.push_back(kProtoSPDY4_15);
   next_protos.push_back(kProtoQUIC1SPDY3);
   return next_protos;
 }
 
 // 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* ChopWriteFrame(const char* data, int length, int num_chunks) {
   MockWrite* chunks = new MockWrite[num_chunks];
@@ skipping 1029 matching lines @@
   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) {
+  if (protocol_ < kProtoSPDY4MinimumVersion) {
     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) {
+  if (protocol_ < kProtoSPDY4MinimumVersion) {
     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 120 matching lines @@
   return is_spdy2() ? "method" : ":method";
 }
 
 const char* SpdyTestUtil::GetStatusKey() const {
   return is_spdy2() ? "status" : ":status";
 }
 
 const char* SpdyTestUtil::GetHostKey() const {
   if (protocol_ < kProtoSPDY3)
     return "host";
-  if (protocol_ < kProtoSPDY4)
+  if (protocol_ < kProtoSPDY4MinimumVersion)
     return ":host";
   else
     return ":authority";
 }
 
 const char* SpdyTestUtil::GetSchemeKey() const {
   return is_spdy2() ? "scheme" : ":scheme";
 }
 
 const char* SpdyTestUtil::GetVersionKey() const {
@@ skipping 38 matching lines @@
   }
 }
 
 void SpdyTestUtil::SetPriority(RequestPriority priority,
                                SpdySynStreamIR* ir) const {
   ir->set_priority(ConvertRequestPriorityToSpdyPriority(
       priority, spdy_version()));
 }
 
 }  // namespace net