Update from https://crrev.com/304121

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 151 matching lines @@
                    SpdyPriority priority,
                    bool fin,
                    bool unidirectional,
                    const SpdyHeaderBlock& headers) override {
     priority_ = priority;
   }
   void OnSynReply(SpdyStreamId stream_id,
                   bool fin,
                   const SpdyHeaderBlock& headers) override {}
   void OnHeaders(SpdyStreamId stream_id,
+                 bool has_priority,
+                 SpdyPriority priority,
                  bool fin,
-                 const SpdyHeaderBlock& headers) override {}
+                 const SpdyHeaderBlock& headers) override {
+    if (has_priority) {
+      priority_ = priority;
+    }
+  }
   void OnDataFrameHeader(SpdyStreamId stream_id,
                          size_t length,
                          bool fin) override {}
   void OnStreamFrameData(SpdyStreamId stream_id,
                          const char* data,
                          size_t len,
                          bool fin) override {}
   void OnSettings(bool clear_persisted) override {}
   void OnSetting(SpdySettingsIds id, uint8 flags, uint32 value) override {}
   void OnPing(SpdyPingId unique_id, bool is_ack) override {}
@@ skipping 116 matching lines @@
       enable_ip_pooling(true),
       enable_compression(false),
       enable_ping(false),
       enable_user_alternate_protocol_ports(false),
       protocol(protocol),
       stream_initial_recv_window_size(kSpdyStreamInitialWindowSize),
       time_func(&base::TimeTicks::Now),
       force_spdy_over_ssl(false),
       force_spdy_always(false),
       use_alternate_protocols(false),
-      enable_websocket_over_spdy(false),
       net_log(NULL) {
   DCHECK(next_proto_is_spdy(protocol)) << "Invalid protocol: " << protocol;
 
   // Note: The CancelledTransaction test does cleanup by running all
   // tasks in the message loop (RunAllPending).  Unfortunately, that
   // doesn't clean up tasks on the host resolver thread; and
   // TCPConnectJob is currently not cancellable.  Using synchronous
   // lookups allows the test to shutdown cleanly.  Until we have
   // cancellable TCPConnectJobs, use synchronous lookups.
   host_resolver->set_synchronous_mode(true);
@@ skipping 13 matching lines @@
       enable_ip_pooling(true),
       enable_compression(false),
       enable_ping(false),
       enable_user_alternate_protocol_ports(false),
       protocol(protocol),
       stream_initial_recv_window_size(kSpdyStreamInitialWindowSize),
       time_func(&base::TimeTicks::Now),
       force_spdy_over_ssl(false),
       force_spdy_always(false),
       use_alternate_protocols(false),
-      enable_websocket_over_spdy(false),
       net_log(NULL) {
   DCHECK(next_proto_is_spdy(protocol)) << "Invalid protocol: " << protocol;
 }
 
 SpdySessionDependencies::~SpdySessionDependencies() {}
 
 // static
 HttpNetworkSession* SpdySessionDependencies::SpdyCreateSession(
     SpdySessionDependencies* session_deps) {
   net::HttpNetworkSession::Params params = CreateSessionParams(session_deps);
@@ skipping 39 matching lines @@
       session_deps->enable_user_alternate_protocol_ports;
   params.spdy_default_protocol = session_deps->protocol;
   params.spdy_stream_initial_recv_window_size =
       session_deps->stream_initial_recv_window_size;
   params.time_func = session_deps->time_func;
   params.next_protos = session_deps->next_protos;
   params.trusted_spdy_proxy = session_deps->trusted_spdy_proxy;
   params.force_spdy_over_ssl = session_deps->force_spdy_over_ssl;
   params.force_spdy_always = session_deps->force_spdy_always;
   params.use_alternate_protocols = session_deps->use_alternate_protocols;
-  params.enable_websocket_over_spdy = session_deps->enable_websocket_over_spdy;
   params.net_log = session_deps->net_log;
   return params;
 }
 
 SpdyURLRequestContext::SpdyURLRequestContext(NextProto protocol,
                                              bool force_spdy_over_ssl,
                                              bool force_spdy_always)
     : storage_(this) {
   DCHECK(next_proto_is_spdy(protocol)) << "Invalid protocol: " << protocol;
 
@@ skipping 304 matching lines @@
       break;
     case SYN_REPLY:
       frame = framer.CreateSynReply(header_info.id, header_info.control_flags,
                                     headers.get());
       break;
     case RST_STREAM:
       frame = framer.CreateRstStream(header_info.id, header_info.status);
       break;
     case HEADERS:
       frame = framer.CreateHeaders(header_info.id, header_info.control_flags,
+                                   header_info.priority,
                                    headers.get());
       break;
     default:
       ADD_FAILURE();
       break;
   }
   return frame;
 }
 
 SpdyFrame* SpdyTestUtil::ConstructSpdyFrame(const SpdyHeaderInfo& header_info,
@@ skipping 297 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