[SPDY] Enable tests for SPDY/3.1 and 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"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "net/cert/mock_cert_verifier.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_network_transaction.h"
 #include "net/http/http_server_properties_impl.h"
 #include "net/socket/socket_test_util.h"
+#include "net/socket/ssl_client_socket.h"
 #include "net/spdy/buffered_spdy_framer.h"
 #include "net/spdy/spdy_framer.h"
 #include "net/spdy/spdy_http_utils.h"
 #include "net/spdy/spdy_session.h"
 #include "net/spdy/spdy_stream.h"
 
 namespace net {
 
 namespace {
 
@@ skipping 11 matching lines @@
   scheme->assign(gurl.scheme());
   host->assign(gurl.host());
   if (gurl.has_port()) {
     host->append(":");
     host->append(gurl.port());
   }
 }
 
 }  // namespace
 
+std::vector<std::string> SpdyNextProtos() {
+  std::vector<std::string> next_protos;
+  for (int i = kProtoMinimumVersion; i <= kProtoMaximumVersion; ++i) {
+    next_protos.push_back(SSLClientSocket::NextProtoToString(
+        static_cast<NextProto>(i)));
+  }
+  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];
   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)
@@ skipping 457 matching lines @@
   case kProtoSPDY31:
     return SPDY3;
   case kProtoSPDY4a2:
     return SPDY4;
   default:
     NOTREACHED();
     return SPDY2;
   }
 }
 
+AlternateProtocol AlternateProtocolFromNextProto(NextProto next_proto) {
+  switch (next_proto) {
+    case kProtoSPDY2:
+      return NPN_SPDY_2;
+    case kProtoSPDY3:
+      return NPN_SPDY_3;
+    case kProtoSPDY31:
+      return NPN_SPDY_3_1;
+    case kProtoSPDY4a2:
+      return NPN_SPDY_4A2;
+
+    case kProtoUnknown:
+    case kProtoHTTP11:
+    case kProtoSPDY1:
+    case kProtoSPDY21:
+      break;
+  }
+
+  NOTREACHED();
+  return NPN_SPDY_2;
+}
+
 SpdyTestUtil::SpdyTestUtil(NextProto protocol)
     : protocol_(protocol),
       spdy_version_(SpdyVersionFromNextProto(protocol)) {
   DCHECK(next_proto_is_spdy(protocol)) << "Invalid protocol: " << protocol;
 }
 
 void SpdyTestUtil::AddUrlToHeaderBlock(base::StringPiece url,
                                        SpdyHeaderBlock* headers) const {
   if (is_spdy2()) {
     (*headers)["url"] = url.as_string();
@@ skipping 523 matching lines @@
   (*headers)[GetSchemeKey()] = scheme.c_str();
   (*headers)[GetVersionKey()] = "HTTP/1.1";
   if (content_length) {
     std::string length_str = base::Int64ToString(*content_length);
     (*headers)["content-length"] = length_str;
   }
   return headers.Pass();
 }
 
 }  // namespace net